noteconnection 1.7.0 → 1.9.0

package/dist/src/frontend/mobile_semantic_comparator.js

@@ -0,0 +1,264 @@
+(function attachMobileSemanticComparator(root, factory) {
+    const api = factory();
+    if (typeof module === 'object' && module.exports) {
+        module.exports = api;
+    }
+    if (root) {
+        root.NoteConnectionMobileSemanticComparator = api;
+    }
+}(typeof globalThis !== 'undefined' ? globalThis : this, function createMobileSemanticComparator() {
+    'use strict';
+
+    const SOURCE_URI_PREFIX = 'note://workspace/v1/';
+    const MAX_DIAGNOSTICS = 64;
+
+    function normalizeText(value) {
+        const text = String(value || '').trim();
+        return typeof text.normalize === 'function' ? text.normalize('NFC') : text;
+    }
+
+    function normalizePath(value) {
+        const text = normalizeText(value)
+            .replace(/\\/g, '/')
+            .replace(/^\/+/, '')
+            .replace(/^knowledge_base\//i, '');
+        const segments = [];
+        for (const segment of text.split('/')) {
+            if (!segment || segment === '.') {
+                continue;
+            }
+            if (segment === '..') {
+                if (segments.length === 0) {
+                    return '';
+                }
+                segments.pop();
+                continue;
+            }
+            segments.push(segment);
+        }
+        return segments.join('/').replace(/\.(?:md|markdown)$/i, '').toLowerCase();
+    }
+
+    function canonicalIdFromSourceUri(sourceUri) {
+        const normalized = normalizeText(sourceUri);
+        if (!normalized.startsWith(SOURCE_URI_PREFIX)) {
+            return '';
+        }
+        try {
+            const decoded = normalized.slice(SOURCE_URI_PREFIX.length)
+                .split('/')
+                .map((segment) => decodeURIComponent(segment))
+                .join('/');
+            return normalizePath(decoded);
+        } catch (_error) {
+            return '';
+        }
+    }
+
+    function normalizeSourceUri(sourceUri) {
+        const normalized = normalizeText(sourceUri);
+        if (!normalized) {
+            return '';
+        }
+        const canonicalId = canonicalIdFromSourceUri(normalized);
+        return canonicalId ? `${SOURCE_URI_PREFIX}${canonicalId.split('/').map(encodeURIComponent).join('/')}.md` : normalized;
+    }
+
+    function nodeCanonicalId(node) {
+        return normalizePath(node && node.canonicalId)
+            || canonicalIdFromSourceUri(node && node.sourceUri)
+            || normalizePath(node && node.id);
+    }
+
+    function nodeIdentity(node) {
+        const canonicalId = nodeCanonicalId(node);
+        if (canonicalId) {
+            return `canonical:${canonicalId}`;
+        }
+        const sourceUri = normalizeSourceUri(node && node.sourceUri);
+        if (sourceUri) {
+            return `uri:${sourceUri}`;
+        }
+        const legacyId = normalizeText(node && node.id).toLowerCase();
+        if (legacyId) {
+            return `legacy:${legacyId}`;
+        }
+        throw new Error('Semantic parity requires every node to expose an identity.');
+    }
+
+    function nodeSignature(node) {
+        return {
+            canonicalId: nodeCanonicalId(node),
+            sourceUri: normalizeSourceUri(node && node.sourceUri),
+        };
+    }
+
+    function endpointIdentity(rawEndpoint, rawUri, nodeById) {
+        const endpointId = rawEndpoint && typeof rawEndpoint === 'object'
+            ? normalizeText(rawEndpoint.id)
+            : normalizeText(rawEndpoint);
+        const node = nodeById.get(endpointId) || nodeById.get(endpointId.toLowerCase());
+        const endpointUri = normalizeSourceUri(rawUri) || normalizeSourceUri(node && node.sourceUri);
+        const canonicalId = nodeCanonicalId(node) || canonicalIdFromSourceUri(rawUri);
+        if (canonicalId) {
+            return {
+                identity: `canonical:${canonicalId}`,
+                sourceUri: endpointUri,
+            };
+        }
+        if (endpointUri) {
+            return {
+                identity: `uri:${endpointUri}`,
+                sourceUri: endpointUri,
+            };
+        }
+        if (endpointId) {
+            return {
+                identity: `legacy:${endpointId.toLowerCase()}`,
+                sourceUri: '',
+            };
+        }
+        throw new Error('Semantic parity requires every edge endpoint to resolve.');
+    }
+
+    function semanticEdge(rawEdge, nodeById) {
+        if (!rawEdge || typeof rawEdge !== 'object') {
+            throw new Error('Semantic parity requires every edge to be an object.');
+        }
+        const source = endpointIdentity(rawEdge.source || rawEdge.from, rawEdge.sourceUri, nodeById);
+        const target = endpointIdentity(rawEdge.target || rawEdge.to, rawEdge.targetUri, nodeById);
+        const type = normalizeText(rawEdge.type) || 'association';
+        const kind = normalizeText(rawEdge.kind).toLowerCase() || 'explicit';
+        const provenance = normalizeText(rawEdge.provenance) || type;
+        return {
+            source: source.identity,
+            target: target.identity,
+            sourceUri: source.sourceUri,
+            targetUri: target.sourceUri,
+            type,
+            kind,
+            provenance,
+        };
+    }
+
+    function edgeKey(edge) {
+        return [
+            edge.source,
+            edge.target,
+            edge.sourceUri,
+            edge.targetUri,
+            edge.type,
+            edge.kind,
+            edge.provenance,
+        ].join('|');
+    }
+
+    function buildIndex(projection, side) {
+        if (!projection || typeof projection !== 'object') {
+            throw new Error(`${side} projection must be an object.`);
+        }
+        const nodes = Array.isArray(projection.nodes) ? projection.nodes : [];
+        const edges = Array.isArray(projection.edges) ? projection.edges : [];
+        const nodeByIdentity = new Map();
+        const nodeById = new Map();
+        nodes.forEach((node) => {
+            const identity = nodeIdentity(node);
+            if (nodeByIdentity.has(identity)) {
+                throw new Error(`${side} projection contains duplicate semantic node identity: ${identity}.`);
+            }
+            const id = normalizeText(node && node.id);
+            if (!id) {
+                throw new Error(`${side} projection contains a node without an id.`);
+            }
+            nodeByIdentity.set(identity, {
+                identity,
+                signature: nodeSignature(node),
+            });
+            nodeById.set(id, node);
+            nodeById.set(id.toLowerCase(), node);
+        });
+
+        const edgeByKey = new Map();
+        edges.forEach((edge) => {
+            const semantic = semanticEdge(edge, nodeById);
+            const key = edgeKey(semantic);
+            if (edgeByKey.has(key)) {
+                throw new Error(`${side} projection contains duplicate semantic edge: ${key}.`);
+            }
+            edgeByKey.set(key, semantic);
+        });
+        return { nodeByIdentity, edgeByKey };
+    }
+
+    function boundedDiagnostics(values) {
+        return values.sort().slice(0, MAX_DIAGNOSTICS);
+    }
+
+    function compareSemanticProjections(leftProjection, rightProjection) {
+        const left = buildIndex(leftProjection, 'left');
+        const right = buildIndex(rightProjection, 'right');
+        const missingNodes = [];
+        const extraNodes = [];
+        const nodeMismatches = [];
+        left.nodeByIdentity.forEach((leftNode, identity) => {
+            const rightNode = right.nodeByIdentity.get(identity);
+            if (!rightNode) {
+                missingNodes.push(identity);
+                return;
+            }
+            if (JSON.stringify(leftNode.signature) !== JSON.stringify(rightNode.signature)) {
+                nodeMismatches.push({ identity, left: leftNode.signature, right: rightNode.signature });
+            }
+        });
+        right.nodeByIdentity.forEach((_rightNode, identity) => {
+            if (!left.nodeByIdentity.has(identity)) {
+                extraNodes.push(identity);
+            }
+        });
+
+        const missingEdges = [];
+        const extraEdges = [];
+        left.edgeByKey.forEach((_edge, key) => {
+            if (!right.edgeByKey.has(key)) {
+                missingEdges.push(key);
+            }
+        });
+        right.edgeByKey.forEach((_edge, key) => {
+            if (!left.edgeByKey.has(key)) {
+                extraEdges.push(key);
+            }
+        });
+
+        return {
+            equal: missingNodes.length === 0
+                && extraNodes.length === 0
+                && nodeMismatches.length === 0
+                && missingEdges.length === 0
+                && extraEdges.length === 0,
+            left: { nodeCount: left.nodeByIdentity.size, edgeCount: left.edgeByKey.size },
+            right: { nodeCount: right.nodeByIdentity.size, edgeCount: right.edgeByKey.size },
+            missingNodes: boundedDiagnostics(missingNodes),
+            extraNodes: boundedDiagnostics(extraNodes),
+            nodeMismatches: nodeMismatches.slice(0, MAX_DIAGNOSTICS),
+            missingEdges: boundedDiagnostics(missingEdges),
+            extraEdges: boundedDiagnostics(extraEdges),
+        };
+    }
+
+    function assertSemanticParity(leftProjection, rightProjection, label) {
+        const comparison = compareSemanticProjections(leftProjection, rightProjection);
+        if (!comparison.equal) {
+            const prefix = label ? `${label}: ` : '';
+            const error = new Error(`${prefix}semantic projection parity failed: ${JSON.stringify(comparison)}`);
+            error.comparison = comparison;
+            throw error;
+        }
+        return comparison;
+    }
+
+    return Object.freeze({
+        canonicalIdFromSourceUri,
+        compareSemanticProjections,
+        assertSemanticParity,
+    });
+}));

package/dist/src/frontend/notemd.css

@@ -249,3 +249,52 @@ input[type="checkbox"] {
     align-items: flex-start;
   }
 }
+
+/* ── Agent Tools ── */
+.badge {
+  background: var(--accent);
+  color: var(--bg-0);
+  font-size: 0.75rem;
+  padding: 0.15em 0.5em;
+  border-radius: 8px;
+  margin-left: 0.5em;
+  vertical-align: middle;
+}
+.agent-tool-card {
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 0.6em 0.9em;
+  margin: 0.3em 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.25em;
+}
+.agent-tool-card.auto-exec {
+  border-left: 3px solid #4caf50;
+}
+.agent-tool-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+.agent-tool-name {
+  font-weight: 600;
+  font-size: 0.85rem;
+}
+.agent-tool-level {
+  font-size: 0.65rem;
+  padding: 0.1em 0.4em;
+  border-radius: 4px;
+  text-transform: uppercase;
+  opacity: 0.85;
+}
+.level-safe       { background: #1b5e20; color: #a5d6a7; }
+.level-requires-active-file { background: #0d47a1; color: #90caf9; }
+.level-requires-selection  { background: #e65100; color: #ffcc80; }
+.level-interactive-ui      { background: #4a148c; color: #ce93d8; }
+.agent-tool-params {
+  font-size: 0.7rem;
+  opacity: 0.6;
+  font-family: monospace;
+}

package/dist/src/frontend/notemd.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta
       http-equiv="Content-Security-Policy"
-      content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self' http://127.0.0.1:* http://localhost:* tauri://localhost http://tauri.localhost; object-src 'none'; base-uri 'self'; frame-ancestors 'self'; form-action 'self';"
+      content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self' ipc: http://127.0.0.1:* http://localhost:* http://ipc.localhost https://ipc.localhost tauri://localhost http://tauri.localhost https://tauri.localhost; object-src 'none'; base-uri 'self'; form-action 'self';"
     />
     <title>NoteMD Workspace</title>
     <link rel="stylesheet" href="notemd.css" />
@@ -146,6 +146,12 @@
         </div>
       </section>
 
+      <section class="panel" id="agent-tools-panel">
+        <h2>Agent Tools <span class="badge" id="agent-op-count"></span></h2>
+        <p class="subtitle">Auto-discovered operations from the Notemd CLI registry. Safe operations can be auto-executed by the Agent Workspace.</p>
+        <div class="grid two" id="agent-tools-grid"></div>
+      </section>
+
       <section class="panel">
         <h2>Logs</h2>
         <pre id="log-output" class="log-output"></pre>

package/dist/src/frontend/notemd.js

@@ -801,4 +801,68 @@
       );
     }
   });
+
+  // ── Agent Tools: fetch & render CLI capability manifest ──
+  async function loadAgentTools() {
+    const grid = document.getElementById('agent-tools-grid');
+    const badge = document.getElementById('agent-op-count');
+    if (!grid || !badge) return;
+
+    try {
+      const res = await fetch('/api/notemd/agent-manifest');
+      if (!res.ok) throw new Error('agent-manifest fetch failed: ' + res.status);
+      const data = await res.json();
+      const manifest = data.manifest;
+      if (!manifest || !Array.isArray(manifest.operations)) return;
+
+      badge.textContent = manifest.agentExecutableCount + ' auto / ' + manifest.totalOperations + ' total';
+
+      const safeLabel = function (level) {
+        switch (level) {
+          case 'safe': return 'auto';
+          case 'requires-active-file': return 'file';
+          case 'requires-selection': return 'select';
+          case 'interactive-ui': return 'ui';
+          default: return level;
+        }
+      };
+
+      manifest.operations.forEach(function (op) {
+        var card = document.createElement('div');
+        card.className = 'agent-tool-card' + (op.agentAutoExecutable ? ' auto-exec' : '');
+        card.title = op.operationId + '\nContext: ' + op.requiredContext + '\nSide Effects: ' + op.sideEffectClass;
+
+        var header = document.createElement('div');
+        header.className = 'agent-tool-header';
+
+        var name = document.createElement('span');
+        name.className = 'agent-tool-name';
+        name.textContent = op.description;
+
+        var level = document.createElement('span');
+        level.className = 'agent-tool-level level-' + op.automationLevel;
+        level.textContent = safeLabel(op.automationLevel);
+
+        var params = document.createElement('div');
+        params.className = 'agent-tool-params';
+        if (op.requiredParams.length > 0) {
+          params.textContent = 'params: ' + op.requiredParams.join(', ');
+        } else {
+          params.textContent = 'no required params';
+        }
+
+        header.appendChild(name);
+        header.appendChild(level);
+        card.appendChild(header);
+        card.appendChild(params);
+        grid.appendChild(card);
+      });
+
+      appendLog('Agent Tools: loaded ' + manifest.totalOperations + ' operations (' + manifest.agentExecutableCount + ' auto-executable)', 'info');
+    } catch (error) {
+      appendLog('Agent Tools failed: ' + (error instanceof Error ? error.message : String(error)), 'warn');
+    }
+  }
+
+  loadAgentTools();
 })();

package/dist/src/frontend/path.html

@@ -40,6 +40,12 @@
                 </select>
             </div>
 
+            <div class="toolbar-group">
+                <button id="btn-toggle-learning-workbench" class="icon-btn" title="Toggle Learning Workbench">
+                    Workbench
+                </button>
+            </div>
+
             <div class="toolbar-group right">
                 <button id="btn-exit-path" class="icon-btn" title="Exit Path Mode">
                     ❌ Exit
@@ -59,14 +65,118 @@
         </div>
     </div>
 
+    <!-- Learning Workbench Sidebar -->
+    <div
+      id="learning-workbench-sidebar"
+      class="path-sidebar workbench-sidebar"
+      style="display: none"
+    >
+      <div class="sidebar-header">
+        <h3>Learning Workbench</h3>
+        <button id="btn-close-learning-workbench" class="close-btn">&times;</button>
+      </div>
+      <div class="sidebar-content workbench-content">
+        <div class="workbench-field">
+          <label for="learning-user-id">Learner ID</label>
+          <input
+            id="learning-user-id"
+            type="text"
+            placeholder="path_user_default"
+          />
+        </div>
+        <div class="workbench-row">
+          <button id="btn-refresh-learning-workbench" class="btn-small">Refresh</button>
+          <button id="btn-ingest-focus-node" class="btn-small">Ingest Focus</button>
+          <button id="btn-run-learning-session" class="btn-small">Run Session</button>
+          <button id="btn-run-retest-session" class="btn-small">Run Retest</button>
+        </div>
+        <div id="learning-workbench-status" class="workbench-status">Ready.</div>
+        <div id="learning-workbench-updated-at" class="workbench-updated-at">Last updated: -</div>
+
+        <div class="workbench-section">
+          <h4>Quality Snapshot</h4>
+          <div class="workbench-row">
+            <button id="btn-set-quality-baseline" class="btn-small" type="button">Set Baseline</button>
+            <button id="btn-evaluate-quality-gates" class="btn-small" type="button">Evaluate Gates</button>
+          </div>
+          <ul id="learning-quality-summary" class="workbench-list">
+            <li class="muted">No quality snapshot yet.</li>
+          </ul>
+          <pre id="learning-quality-gates" class="workbench-feedback">No quality gate evaluation yet.</pre>
+        </div>
+
+        <div class="workbench-section">
+          <h4>Top Misconceptions</h4>
+          <ul id="learning-misconception-list" class="workbench-list">
+            <li class="muted">No recurring misconceptions detected.</li>
+          </ul>
+        </div>
+
+        <div class="workbench-section">
+          <h4>Session Actions</h4>
+          <ul id="learning-session-actions" class="workbench-list">
+            <li class="muted">No session actions yet.</li>
+          </ul>
+        </div>
+
+        <div class="workbench-section">
+          <h4>Tutor Feedback</h4>
+          <pre id="learning-tutor-feedback" class="workbench-feedback">No tutor feedback yet.</pre>
+        </div>
+
+        <div class="workbench-section">
+          <h4>Session Execution</h4>
+          <pre id="learning-session-execution" class="workbench-feedback">No session execution yet.</pre>
+        </div>
+
+        <div class="workbench-section">
+          <h4>Session History</h4>
+          <div class="workbench-row">
+            <label for="learning-history-kind-filter">Kind</label>
+            <select id="learning-history-kind-filter" class="control-select">
+              <option value="all">All</option>
+              <option value="session">Session</option>
+              <option value="retest">Retest</option>
+              <option value="custom">Custom</option>
+            </select>
+            <button id="btn-learning-history-prev" class="btn-small" type="button">Prev</button>
+            <button id="btn-learning-history-next" class="btn-small" type="button">Next</button>
+            <span id="learning-history-page" class="muted">Page 1/1</span>
+          </div>
+          <div class="workbench-row">
+            <label for="learning-history-from-date">From</label>
+            <input id="learning-history-from-date" type="date" class="control-input" />
+            <label for="learning-history-to-date">To</label>
+            <input id="learning-history-to-date" type="date" class="control-input" />
+            <button id="btn-learning-history-apply-range" class="btn-small" type="button">Apply</button>
+            <button id="btn-learning-history-clear-range" class="btn-small" type="button">Clear</button>
+          </div>
+          <div id="learning-session-history-summary" class="workbench-runtime">
+            History summary: unavailable
+          </div>
+          <ul id="learning-session-history" class="workbench-list">
+            <li class="muted">No session history yet.</li>
+          </ul>
+        </div>
+
+        <div id="learning-runtime-summary" class="workbench-runtime">
+          Runtime: unavailable
+        </div>
+      </div>
+    </div>
+
     <!-- Reading Mode Dependencies -->
     <script src="libs/marked.min.js"></script>
     <link rel="stylesheet" href="libs/katex/katex.min.css" />
     <script src="libs/katex/katex.min.js"></script>
     <script src="libs/katex/contrib/auto-render.min.js"></script>
     <script src="libs/mermaid.min.js"></script>
-    <script src="runtime_bridge.js"></script>
-    <script src="storage_provider.js"></script>
+     <script src="runtime_bridge.js"></script>
+     <script src="knowledge_projection_contract.js"></script>
+     <script src="knowledge_projection_store.js"></script>
+     <script src="mobile_exact_analyzer.js"></script>
+     <script src="mobile_identity_contract.js"></script>
+     <script src="storage_provider.js"></script>
     <script src="reader.js"></script>
 
     <!-- Reading Window -->
@@ -97,6 +207,7 @@
 
     <!-- Scripts -->
     <script src="i18n.js"></script>
+    <script src="path_modules_bridge.js"></script>
     <script src="path_app.js"></script>
 </body>
 </html>