jevgraph 0.2.0a1__py3-none-any.whl

jevgraph/__init__.py

@@ -0,0 +1,23 @@
+"""JEVGRAPH: build reusable evidence graphs as agents search."""
+
+from .client import IngestionClient
+from .graph import Graph
+from .judges import JevJudge, Judge, ProviderError
+from .types import Budget, Edge, Evaluation, Node, Path, Policy, Relation, SearchResult
+
+__all__ = [
+    "Budget",
+    "Edge",
+    "Evaluation",
+    "Graph",
+    "IngestionClient",
+    "JevJudge",
+    "Judge",
+    "Node",
+    "Path",
+    "Policy",
+    "ProviderError",
+    "Relation",
+    "SearchResult",
+]
+__version__ = "0.2.0a1"

jevgraph/cli.py

@@ -0,0 +1,104 @@
+"""The demo is offline unless --live is supplied explicitly."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+from .demo import DEMO_NODES, DEMO_QUERY, DEMO_RELATIONS, DemoJudge
+from .graph import Graph
+from .judges import JevJudge
+from .types import Budget
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="JEVGRAPH: graphs that grow as agents search")
+    commands = parser.add_subparsers(dest="command", required=True)
+    demo = commands.add_parser("demo", help="Run the synthetic dependency-chain example")
+    demo.add_argument("--live", action="store_true", help="Send synthetic records to TypeSafe JEV")
+    demo.add_argument("--db", default=":memory:", help="SQLite path for persistent graph memory")
+    demo.add_argument("--json", action="store_true", help="Print complete trace and graph JSON")
+    demo.add_argument("--out", type=Path, help="Save complete trace and graph JSON")
+    server = commands.add_parser("serve", help="Open the local workspace search app")
+    server.add_argument("--db", default="workspace.sqlite")
+    server.add_argument("--token-file", default=".jevgraph/access.json")
+    server.add_argument("--port", type=int, default=8765)
+    server.add_argument("--live", action="store_true", help="Enable optional JEV graph exploration")
+    ingest = commands.add_parser("ingest", help="Send a JSON dump to your workspace")
+    ingest.add_argument("file", type=Path)
+    ingest.add_argument("--server", default="http://127.0.0.1:8765")
+    ingest.add_argument("--token-file", default=".jevgraph/access.json")
+    args = parser.parse_args()
+    try:
+        if args.command == "ingest":
+            from .client import IngestionClient
+
+            access_token = os.environ.get("JEVGRAPH_ACCESS_TOKEN", "")
+            if not access_token:
+                configured = json.loads(Path(args.token_file).read_text())
+                if len(configured) != 1:
+                    parser.error("Set JEVGRAPH_ACCESS_TOKEN to select your account")
+                access_token = next(iter(configured))
+            payload = json.loads(args.file.read_text())
+            records = payload if isinstance(payload, list) else payload.get("records")
+            print(json.dumps(IngestionClient(args.server, access_token).ingest(records), indent=2))
+            return
+        if args.command == "serve":
+            try:
+                from .server import serve
+            except ImportError:
+                parser.error("Install server dependencies with: pip install '.[server]'")
+            serve(args.db, args.token_file, args.port, args.live)
+            return
+        judge = JevJudge() if args.live else DemoJudge()
+        with Graph(args.db, name="dependency-demo", relations=DEMO_RELATIONS, judge=judge) as graph:
+            for node in DEMO_NODES:
+                graph.add(node)
+            result = graph.search(
+                DEMO_QUERY,
+                start=["edgerouter"],
+                budget=Budget(max_calls=32, max_questions=100, candidates_per_node=3),
+            )
+            payload = {
+                "mode": "live-jev" if args.live else "scripted-offline-demo",
+                "result": result.to_dict(),
+                "graph": graph.export(),
+            }
+        rendered = json.dumps(payload, indent=2, allow_nan=False)
+        if args.out:
+            args.out.parent.mkdir(parents=True, exist_ok=True)
+            args.out.write_text(rendered + "\n")
+        if args.json:
+            print(rendered)
+        else:
+            print(f"JEVGRAPH | {payload['mode']}")
+            print(
+                "Fixture answers exercise the code; they do not measure JEV quality."
+                if not args.live
+                else "Synthetic source records evaluated by the live JEV API."
+            )
+            print(f"Stop: {result.stop_reason}")
+            best = max(result.paths, key=lambda p: (p.goal_probability, p.priority), default=None)
+            if best:
+                print("Path: " + " -> ".join(best.nodes))
+            print(f"Judge calls: {result.calls} | questions: {result.questions}")
+            print(
+                "Reused judgments: "
+                + str(
+                    sum(t.get("count", 0) for t in result.trace if t["event"] == "judgment_cache")
+                )
+            )
+            print(
+                "Supported relationships: "
+                + str(sum(e["status"] == "supported" for e in payload["graph"]["judgments"]))
+            )
+        if result.stop_reason == "provider_error":
+            raise SystemExit(2)
+    except (ValueError, OSError) as exc:
+        parser.error(str(exc))
+
+
+if __name__ == "__main__":
+    main()

jevgraph/client.py

@@ -0,0 +1,55 @@
+"""Small ingestion client for browser agents and existing export pipelines."""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from urllib.parse import urlsplit
+
+from .types import canonical
+from .workspace import validate_record
+
+
+class _NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+class IngestionClient:
+    def __init__(self, server: str, token: str):
+        parts = urlsplit(server)
+        if parts.username or parts.password or parts.query or parts.fragment:
+            raise ValueError("Use the workspace origin without credentials or query parameters")
+        if parts.path not in {"", "/"} or not parts.hostname:
+            raise ValueError("Use the workspace origin without a path")
+        if parts.scheme != "https" and not (
+            parts.scheme == "http" and parts.hostname in {"localhost", "127.0.0.1"}
+        ):
+            raise ValueError("Use HTTPS or a loopback HTTP workspace")
+        if not token:
+            raise ValueError("A workspace access token is required")
+        self.server = server.rstrip("/")
+        self._token = token
+
+    def ingest(self, records: list[dict]) -> dict:
+        if not isinstance(records, list) or not 1 <= len(records) <= 50:
+            raise ValueError("Send 1–50 records per batch")
+        payload = canonical({"records": [validate_record(record) for record in records]}).encode()
+        if len(payload) > 2_000_000:
+            raise ValueError("Batch exceeds 2 MB")
+        request = urllib.request.Request(
+            self.server + "/api/ingest",
+            data=payload,
+            method="POST",
+            headers={"Authorization": "Bearer " + self._token, "Content-Type": "application/json"},
+        )
+        try:
+            with urllib.request.build_opener(_NoRedirect()).open(request, timeout=30) as response:
+                return json.loads(response.read(256000))
+        except urllib.error.HTTPError as error:
+            raise ValueError(f"Ingestion returned HTTP {error.code}; no retry attempted") from None
+        except (OSError, ValueError):
+            raise ValueError(
+                "Unable to read ingestion response; check server and retry the batch"
+            ) from None

jevgraph/demo.py

@@ -0,0 +1,48 @@
+"""Synthetic fixture for exercising mechanics, explicitly not model evidence."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .types import Evaluation, Node, Relation
+
+DEMO_RELATIONS = [Relation(
+    "depends_on", "The source service requires the target service to perform its function.",
+    "service", "service",
+)]
+DEMO_NODES = [
+    Node("edgerouter", "EdgeRouter forwards checkout requests to Checkout. "
+         "EdgeRouter depends on Checkout.", "service", "fixture://architecture/edgerouter"),
+    Node("checkout", "Checkout submits card charges to Payments. Checkout depends on Payments.",
+         "service", "fixture://architecture/checkout"),
+    Node("payments", "Payments authenticates through Identity. Payments depends on Identity.",
+         "service", "fixture://architecture/payments"),
+    Node("identity", "Identity issues access tokens for signed-in sessions.",
+         "service", "fixture://architecture/identity"),
+    Node("legacy", "LegacyAuth and Checkout were discussed in a proposal. "
+         "Checkout does not depend on LegacyAuth.", "service", "fixture://architecture/legacy"),
+]
+DEMO_QUERY = "Starting at EdgeRouter, find a chain of service dependencies reaching Identity."
+
+
+class DemoJudge:
+    """Hard-coded answers for these five records only. No semantic inference."""
+
+    cache_key = "scripted-demo-v1"
+    pairs = {("edgerouter", "checkout"), ("checkout", "payments"), ("payments", "identity")}
+
+    def evaluate(self, state: dict[str, Any], questions: dict[str, str]) -> Evaluation:
+        if "source" in state:
+            pair = (state["source"]["id"], state["target"]["id"])
+            values = {key: (0.98 if pair in self.pairs else 0.02)
+                      if key.startswith("support_") else
+                      (0.98 if pair == ("checkout", "legacy") else 0.02)
+                      for key in questions}
+        elif "goal" in questions:
+            ids = [node["id"] for node in state["path"]["nodes"]]
+            values = {"goal": 0.98 if ids == ["edgerouter", "checkout", "payments", "identity"]
+                      else 0.02}
+        else:
+            values = {key: 0.98 for key in questions}
+        return Evaluation(values, "scripted-demo-v1")
+

jevgraph/extension/background.js

@@ -0,0 +1,113 @@
+import { capturePage } from './capture.js';
+
+chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true });
+chrome.storage.local.setAccessLevel({ accessLevel: 'TRUSTED_CONTEXTS' });
+let processing = false;
+let edits = Promise.resolve();
+const hash = async value => [...new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode(value)))].map(b => b.toString(16).padStart(2, '0')).join('');
+const fingerprint = settings => hash(settings.baseUrl + ':' + settings.token);
+
+function baseUrl(value) {
+  const url = new URL(value);
+  if (url.username || url.password || url.search || url.hash || url.pathname !== '/') throw new Error('Use the workspace origin, without a path or credentials.');
+  if (url.protocol !== 'https:' && !(url.protocol === 'http:' && ['localhost', '127.0.0.1'].includes(url.hostname))) throw new Error('Use HTTPS, or a local workspace on localhost.');
+  return url.origin;
+}
+async function request(settings, path, options = {}) {
+  const response = await fetch(settings.baseUrl + '/api/' + path, {
+    ...options, redirect: 'error', signal: AbortSignal.timeout(20000),
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${settings.token}` },
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(payload.detail || `Workspace returned ${response.status}`);
+  return payload;
+}
+function editJobs(change) {
+  const run = edits.then(async () => {
+    const { jobs = [] } = await chrome.storage.local.get('jobs');
+    const next = await change(jobs);
+    await chrome.storage.local.set({ jobs: next });
+    return next;
+  });
+  edits = run.catch(() => {});
+  return run;
+}
+async function settingsOrFail() {
+  const { settings } = await chrome.storage.local.get('settings');
+  if (!settings?.token) throw new Error('Connect your workspace in Settings first.');
+  return settings;
+}
+async function enqueue(tabIds) {
+  const settings = await settingsOrFail();
+  if (!Array.isArray(tabIds) || !tabIds.length || tabIds.length > 20) throw new Error('Select between 1 and 20 tabs.');
+  const scope = await fingerprint(settings);
+  const tabs = await Promise.all([...new Set(tabIds)].map(id => chrome.tabs.get(id)));
+  if (tabs.some(tab => tab.incognito || !/^https?:\/\//.test(tab.url || ''))) throw new Error('Select ordinary HTTP(S) tabs outside incognito.');
+  await editJobs(jobs => {
+    const active = jobs.filter(job => ['pending', 'capturing'].includes(job.status));
+    if (active.length + tabs.length > 20) throw new Error('The queue supports 20 active captures.');
+    const next = tabs.map(tab => ({ id: crypto.randomUUID(), tabId: tab.id, tabUrl: tab.url,
+      title: tab.title || 'Page', status: 'pending', scope, createdAt: new Date().toISOString() }));
+    return [...jobs.filter(job => !active.includes(job)).slice(-(20 - active.length - next.length) || jobs.length), ...active, ...next].slice(-20);
+  });
+  await chrome.alarms.create('capture-queue', { periodInMinutes: 1 });
+  void drain();
+  return { queued: tabs.length };
+}
+async function drain() {
+  if (processing) return;
+  processing = true;
+  try {
+    const { jobs = [] } = await chrome.storage.local.get('jobs');
+    const job = jobs.find(item => ['pending', 'capturing'].includes(item.status));
+    if (!job) { await chrome.alarms.clear('capture-queue'); return; }
+    try {
+      const settings = await settingsOrFail();
+      if (await fingerprint(settings) !== job.scope) throw new Error('Workspace connection changed. Capture this page again for the new connection.');
+      await editJobs(list => list.map(item => item.id === job.id ? { ...item, status: 'capturing', error: '' } : item));
+      let record = job.record;
+      if (!record) {
+        const tab = await chrome.tabs.get(job.tabId);
+        if (tab.incognito || tab.url !== job.tabUrl) throw new Error('The tab navigated or closed. Select it again to capture its current page.');
+        const [{ result }] = await chrome.scripting.executeScript({ target: { tabId: job.tabId }, func: capturePage });
+        if (!result || result._originalUrl !== job.tabUrl) throw new Error('Page changed during capture. Select it again.');
+        record = { ...result, external_id: 'browser:' + await hash(result._identity) };
+        delete record._originalUrl; delete record._identity;
+        await editJobs(list => list.map(item => item.id === job.id ? { ...item, record } : item));
+      }
+      const receipt = await request(settings, 'ingest', { method: 'POST', body: JSON.stringify({ records: [record] }) });
+      await editJobs(list => list.map(item => item.id === job.id ? { ...item, status: 'saved', receipt, title: record.title } : item));
+    } catch (error) {
+      await editJobs(list => list.map(item => item.id === job.id ? { ...item, status: 'failed', error: error.message } : item));
+    }
+  } finally {
+    processing = false;
+    const { jobs = [] } = await chrome.storage.local.get('jobs');
+    if (jobs.some(job => job.status === 'pending')) void drain();
+  }
+}
+chrome.alarms.onAlarm.addListener(alarm => { if (alarm.name === 'capture-queue') void drain(); });
+chrome.runtime.onStartup.addListener(() => { void drain(); });
+chrome.runtime.onMessage.addListener((message, sender, reply) => {
+  // Only our extension pages may invoke authenticated ingestion or search.
+  if (sender.id !== chrome.runtime.id || !sender.url?.startsWith(`chrome-extension://${chrome.runtime.id}/`)) return false;
+  (async () => {
+    if (message.type === 'connect') {
+      const settings = { baseUrl: baseUrl(message.baseUrl), token: String(message.token).trim() };
+      const me = await request(settings, 'me');
+      await chrome.storage.local.set({ settings: { ...settings, me } });
+      return me;
+    }
+    if (message.type === 'capture') return enqueue(message.tabIds);
+    if (message.type === 'search') return request(await settingsOrFail(), 'search', { method: 'POST', body: JSON.stringify({ query: String(message.query), explore: false }) });
+    if (message.type === 'retry') {
+      await editJobs(jobs => jobs.map(job => job.status === 'failed' ? { ...job, status: 'pending', error: '' } : job));
+      await chrome.alarms.create('capture-queue', { periodInMinutes: 1 }); void drain(); return { ok: true };
+    }
+    if (message.type === 'clear') {
+      await editJobs(jobs => jobs.filter(job => ['pending', 'capturing'].includes(job.status))); return { ok: true };
+    }
+    throw new Error('Unknown action');
+  })().then(data => reply({ ok: true, data }), error => reply({ ok: false, error: error.message }));
+  return true;
+});

jevgraph/extension/capture.js

@@ -0,0 +1,34 @@
+// Self-contained: Chrome serializes this function into an isolated content world.
+export function capturePage() {
+  if (!['http:', 'https:'].includes(location.protocol)) throw new Error('Only web pages can be captured.');
+  const originalUrl = location.href;
+  const url = new URL(originalUrl);
+  url.username = ''; url.password = '';
+  const allowed = new Set(['id', 'page', 'record', 'issue', 'view']);
+  for (const key of [...url.searchParams.keys()]) if (!allowed.has(key.toLowerCase())) url.searchParams.delete(key);
+  url.searchParams.sort();
+  url.hash = location.hash.startsWith('#/') ? location.hash.split('?')[0] : '';
+  const root = document.querySelector('main, article, [role="main"]') || document.body;
+  if (!root) throw new Error('This page has no readable content.');
+  const excluded = 'script,style,noscript,input,textarea,select,button,nav,footer,[contenteditable],[hidden],[aria-hidden="true"]';
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  let text = '', count = 0, truncated = false;
+  while (walker.nextNode()) {
+    if (++count > 60000) { truncated = true; break; }
+    const current = walker.currentNode;
+    const parent = current.parentElement;
+    if (!parent || parent.closest(excluded)) continue;
+    const style = getComputedStyle(parent);
+    if (!parent.getClientRects().length || style.visibility === 'hidden' || style.display === 'none' || style.opacity === '0') continue;
+    const value = current.textContent.replace(/\s+/g, ' ').trim();
+    if (!value) continue;
+    if (text.length + value.length + 1 > 100000) {
+      text += value.slice(0, Math.max(0, 100000 - text.length)); truncated = true; break;
+    }
+    text += value + '\n';
+  }
+  if (!text.trim()) throw new Error('No readable page text. Try a source export for this page.');
+  return { title: (document.title || url.hostname).slice(0, 500), url: url.href, text: text.trim(),
+    source_type: 'browser', visibility: 'private', truncated, _originalUrl: originalUrl,
+    _identity: url.href };
+}

jevgraph/extension/manifest.json

@@ -0,0 +1,14 @@
+{
+  "manifest_version": 3,
+  "name": "JEVGRAPH — Workspace capture",
+  "version": "0.2.0",
+  "description": "Capture selected pages, collect tabs, and search your private JEVGRAPH workspace.",
+  "minimum_chrome_version": "116",
+  "permissions": ["activeTab", "scripting", "storage", "sidePanel", "tabs", "alarms"],
+  "host_permissions": ["http://127.0.0.1/*", "http://localhost/*"],
+  "optional_host_permissions": ["https://*/*", "http://*/*"],
+  "background": {"service_worker": "background.js", "type": "module"},
+  "action": {"default_title": "Open JEVGRAPH"},
+  "side_panel": {"default_path": "panel.html"},
+  "content_security_policy": {"extension_pages": "script-src 'self'; object-src 'self'"}
+}

jevgraph/extension/panel.css

@@ -0,0 +1 @@
+:root{font-family:Inter,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;color:#304a36;background:#f9faf6;font-synthesis:none}*{box-sizing:border-box}body{margin:0;padding:21px;min-width:280px}button,input{font:inherit}button{cursor:pointer}[hidden]{display:none!important}header{display:flex;align-items:center;justify-content:space-between;padding:3px 0 22px}.brand{display:flex;gap:9px;align-items:center;font-weight:750;font-size:16px;letter-spacing:-.5px}.brand>span{background:#254b3b;border-radius:9px;color:#d4e8a7;width:29px;height:29px;display:grid;place-items:center;font-size:26px}a{color:#56764f;text-decoration:none}header>a{font-size:22px}.workspace{display:flex;align-items:center;gap:8px;font-size:10px;border:1px solid #e0e6d8;border-radius:8px;padding:13px;background:#f0f4e9}.dot{height:5px;width:5px;border-radius:50%;background:#8da774}.badge{margin-left:auto;font-size:9px;color:#849575}nav{display:flex;border-bottom:1px solid #e1e6d8;margin:25px 0}nav button{border:0;background:none;padding:12px 14px;color:#87917e;font-size:12px}nav button.active{color:#315635;border-bottom:2px solid #496c43}.eyebrow{font-size:8px;letter-spacing:1.4px;color:#8a9c78}h1{font-size:32px;font-weight:460;line-height:1.2;letter-spacing:-1.2px;margin:16px 0}p{font-size:12px;line-height:1.8;color:#85917a}button.primary,button.secondary{border:1px solid transparent;padding:13px 16px;border-radius:8px;width:100%;font-size:12px;font-weight:550;margin-top:10px}.primary{background:#29573f;color:#fff}.primary:hover{background:#376b4b}.secondary{background:#eaf0e2;color:#45663d;border-color:#dce6d2!important}.section-head{display:flex;justify-content:space-between;align-items:center;margin:29px 0 15px}h2{font-size:12px;font-weight:550;margin:0}.text-button{border:0;padding:0;background:none;font-size:10px;color:#6f8c5b}.tab-list{max-height:225px;overflow:auto;border:1px solid #e0e6d9;border-radius:8px}.tab-item{display:flex!important;align-items:center;gap:9px;padding:11px;margin:0!important;border-bottom:1px solid #e5eadf}.tab-item:last-child{border:0}.tab-item input{width:13px;margin:0;accent-color:#456d3c;flex-shrink:0}.tab-item div{min-width:0}.tab-item strong{font-size:11px;font-weight:500;display:block;white-space:nowrap;text-overflow:ellipsis;overflow:hidden;color:#57694b}.tab-item small{font-size:9px;color:#a0aa96;display:block;margin-top:4px}.fine{font-size:10px;line-height:1.8}label{display:block;margin:17px 0 8px;font-size:11px;color:#6d7e60}input{width:100%;border:1px solid #dce4d1;border-radius:7px;padding:12px;color:#3d5633;background:#fff;outline-color:#91af7c;font-size:12px}.job{padding:12px 0;border-bottom:1px solid #e4e9dd}.job strong{font-size:11px;font-weight:500;display:block}.job small{font-size:10px;display:block;margin-top:6px;color:#90a07f}.job.failed small{color:#ac6755}.job.saved small{color:#608953}.queue-actions{display:flex;justify-content:space-between;gap:10px;margin:17px 0}.empty{font-size:11px;color:#98a68b;border:1px dashed #dbe3d1;border-radius:8px;padding:18px;line-height:1.8}.result{padding:16px 0;border-bottom:1px solid #e2e7dc}.result a{font-size:13px;font-weight:550}.result p{font-size:11px;margin-bottom:6px;overflow-wrap:anywhere}.result small{font-size:9px;color:#96a48a}#status{position:sticky;bottom:10px;background:#2a5039;color:white;font-size:11px;line-height:1.6;border-radius:8px;padding:12px;margin-top:20px;overflow-wrap:anywhere}footer{font-size:9px;letter-spacing:.5px;color:#a4ae9a;border-top:1px solid #e3e9da;margin-top:30px;padding-top:18px}button:focus-visible,a:focus-visible{outline:2px solid #85a473;outline-offset:3px}button:disabled{opacity:.45;cursor:not-allowed}

jevgraph/extension/panel.html

@@ -0,0 +1,8 @@
+<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>JEVGRAPH capture</title><link rel="stylesheet" href="panel.css"><script type="module" src="panel.js"></script></head><body>
+<header><div class="brand"><span>✳</span> JEVGRAPH</div><a id="open-workspace" href="http://127.0.0.1:8765" target="_blank" rel="noopener noreferrer" aria-label="Open workspace">↗</a></header>
+<div class="workspace"><span class="dot"></span><span id="workspace-label">Connect your workspace</span><span class="badge">Private</span></div>
+<nav><button class="active" data-tab="capture">Capture</button><button data-tab="search">Search</button><button data-tab="settings">Settings</button></nav>
+<section id="capture-tab"><span class="eyebrow">KEEP WHAT MATTERS</span><h1>The page now.<br>The context later.</h1><p>Save readable page text to your private workspace. Search it whenever you need it.</p><button id="capture-current" class="primary">＋ Capture this page</button><div class="section-head"><h2>Collect a set of tabs</h2><button id="refresh-tabs" class="text-button">Refresh</button></div><div id="tab-list" class="tab-list"></div><button id="capture-selected" class="secondary">Collect selected tabs</button><p class="fine">You choose the pages. Chrome asks for access to the selected sites. Captures include only loaded page text.</p><div class="section-head"><h2>Capture queue</h2><button id="retry" class="text-button">Retry failed</button></div><div id="jobs"></div><div class="queue-actions"><button id="export" class="text-button">Export captured JSON ↓</button><button id="clear" class="text-button">Clear finished</button></div></section>
+<section id="search-tab" hidden><span class="eyebrow">YOUR WORK, CONNECTED</span><h1>Find it here.</h1><form id="search-form"><label for="query">Search your workspace</label><input id="query" required placeholder="A project, decision, or useful page…"><button class="primary" type="submit">Search →</button></form><div id="results"></div></section>
+<section id="settings-tab" hidden><span class="eyebrow">YOUR CONNECTION</span><h1>A home for<br>your knowledge.</h1><form id="settings-form"><label for="base-url">Workspace URL</label><input id="base-url" type="url" required value="http://127.0.0.1:8765"><label for="token">Access token</label><input id="token" type="password" required autocomplete="off" placeholder="From your workspace access file"><button class="primary" type="submit">Connect workspace →</button></form><p class="fine">The workspace token stays in extension storage. Page captures exclude form fields and editable areas. Website cookies and passwords are not collected.</p></section>
+<div id="status" role="status" hidden></div><footer>JEVGRAPH · Browser companion</footer></body></html>

jevgraph/extension/panel.js

@@ -0,0 +1,82 @@
+const $ = id => document.getElementById(id);
+let listedTabs = [];
+let currentJobs = [];
+function el(tag, className, text) { const n = document.createElement(tag); if (className) n.className = className; if (text !== undefined) n.textContent = text; return n; }
+function status(message) { $('status').textContent = message; $('status').hidden = false; }
+async function send(message) { const result = await chrome.runtime.sendMessage(message); if (!result?.ok) throw new Error(result?.error || 'Extension did not respond.'); return result.data; }
+function tab(name) { for (const item of document.querySelectorAll('section')) item.hidden = item.id !== name + '-tab'; for (const button of document.querySelectorAll('[data-tab]')) button.classList.toggle('active', button.dataset.tab === name); }
+async function refreshTabs() {
+  listedTabs = (await chrome.tabs.query({ currentWindow: true })).filter(item => !item.incognito && /^https?:\/\//.test(item.url || ''));
+  $('tab-list').replaceChildren(...listedTabs.map(item => {
+    const row = el('label', 'tab-item'); const check = el('input'); check.type = 'checkbox'; check.value = item.id;
+    const text = el('div'); text.append(el('strong', '', item.title || 'Page'), el('small', '', new URL(item.url).hostname)); row.append(check, text); return row;
+  }));
+  if (!listedTabs.length) $('tab-list').append(el('div', 'empty', 'Open a web page to start collecting.'));
+}
+async function renderJobs() {
+  const { jobs = [] } = await chrome.storage.local.get('jobs'); currentJobs = jobs;
+  $('jobs').replaceChildren(...jobs.slice().reverse().map(job => {
+    const row = el('div', 'job ' + job.status); row.append(el('strong', '', job.title), el('small', '', job.status === 'failed' ? job.error : job.status === 'saved' ? 'Saved to your private workspace' + (job.record?.truncated ? ' · text truncated' : '') : job.status === 'capturing' ? 'Capturing and uploading…' : 'Queued')); return row;
+  }));
+  if (!jobs.length) $('jobs').append(el('div', 'empty', 'Your next useful page belongs here.'));
+  $('retry').disabled = !jobs.some(job => job.status === 'failed');
+  $('export').disabled = !jobs.some(job => job.record);
+  if (jobs.length && !jobs.some(job => ['pending', 'capturing'].includes(job.status))) {
+    const saved = jobs.filter(job => job.status === 'saved').length;
+    const failed = jobs.filter(job => job.status === 'failed').length;
+    status(failed ? `${saved} saved · ${failed} need attention.` : `${saved} captured pages are ready to search.`);
+  }
+}
+async function loadSettings() {
+  const { settings } = await chrome.storage.local.get('settings');
+  if (settings) {
+    $('base-url').value = settings.baseUrl; $('token').value = settings.token;
+    $('workspace-label').textContent = settings.me.workspace; $('open-workspace').href = settings.baseUrl;
+  } else tab('settings');
+}
+for (const button of document.querySelectorAll('[data-tab]')) button.onclick = () => tab(button.dataset.tab);
+$('refresh-tabs').onclick = () => refreshTabs().catch(error => status(error.message));
+$('settings-form').onsubmit = async event => {
+  event.preventDefault();
+  try {
+    const target = new URL($('base-url').value);
+    const origin = target.protocol + '//' + target.hostname;
+    const granted = await chrome.permissions.request({ origins: [origin + '/*'] });
+    if (!granted) throw new Error('Workspace access was not granted.');
+    await send({ type: 'connect', baseUrl: $('base-url').value, token: $('token').value });
+    await loadSettings(); tab('capture'); status('Workspace connected.');
+  } catch (error) { status(error.message); }
+};
+$('capture-current').onclick = async () => {
+  try { const [current] = await chrome.tabs.query({ active: true, currentWindow: true }); await send({ type: 'capture', tabIds: [current.id] }); status('Page queued. If access is denied, click the toolbar icon on this page and try again.'); }
+  catch (error) { status(error.message); }
+};
+$('capture-selected').onclick = async () => {
+  try {
+    const ids = [...$('tab-list').querySelectorAll('input:checked')].map(input => Number(input.value));
+    if (!ids.length || ids.length > 20) throw new Error('Select between 1 and 20 tabs.');
+    const origins = [...new Set(listedTabs.filter(item => ids.includes(item.id)).map(item => { const url = new URL(item.url); return url.protocol + '//' + url.hostname + '/*'; }))];
+    if (!await chrome.permissions.request({ origins })) throw new Error('Access to selected sites was not granted.');
+    await send({ type: 'capture', tabIds: ids }); status(`${ids.length} selected pages queued.`);
+  } catch (error) { status(error.message); }
+};
+$('retry').onclick = () => send({ type: 'retry' }).then(() => status('Retrying failed captures.')).catch(error => status(error.message));
+$('clear').onclick = () => send({ type: 'clear' }).catch(error => status(error.message));
+$('export').onclick = () => {
+  const records = currentJobs.filter(job => job.record).map(job => job.record);
+  const link = el('a'); const url = URL.createObjectURL(new Blob([JSON.stringify({ records }, null, 2)], { type: 'application/json' }));
+  link.href = url; link.download = 'jevgraph-captures.json'; link.click(); setTimeout(() => URL.revokeObjectURL(url), 30000);
+};
+$('search-form').onsubmit = async event => {
+  event.preventDefault(); $('results').replaceChildren(el('div', 'empty', 'Searching…'));
+  try {
+    const result = await send({ type: 'search', query: $('query').value });
+    $('results').replaceChildren(...result.results.map(doc => {
+      const card = el('article', 'result'); const link = el('a', '', doc.title); link.href = doc.url; link.target = '_blank'; link.rel = 'noopener noreferrer';
+      card.append(link, el('p', '', doc.excerpt), el('small', '', new URL(doc.url).hostname)); return card;
+    }));
+    if (!result.results.length) $('results').append(el('div', 'empty', 'No matching pages yet. Try another phrase or capture more pages.'));
+  } catch (error) { $('results').replaceChildren(el('div', 'empty', error.message)); }
+};
+chrome.storage.onChanged.addListener(changes => { if (changes.jobs) void renderJobs(); });
+await loadSettings(); await refreshTabs(); await renderJobs();