← Home

SovrenAI Barcode Code

▶ Run New Project ⚙ Build Itself

Profile Log Out

Log In

Intent

Atoms

Domains

Select project...

Claim: · Spec:

Describe what you want to build. Say "build it" when you approve the plan.

Send

Code: —

FN-: —

Bonds: —

All domains

Search the dictionary to find composable functions

Composition Suggestions (Gate C1)

Describe what you want and we'll find reusable code for it

Domains

Loading domains...

Code

ToBi

Versions

Analytics

DevTools

Describe what you want to build in the left panel, then say "build it" when ready.

Clear Copy

Save Version + File

ToBi Tool Calls

No ToBi session yet. Submit an intent to see tool calls.

Build Version Chain (BLD-)

No builds yet. Save code to start the chain.

Dictionary

—

Composition Rate

Session

Build History

Tool Usage

Tier Distribution

Health

Atom Query

Query

Barcode Resolver

Resolve

Network Monitor

Ctrl+S save | Ctrl+? help

Canvas

Gates

Export

Release

▶ Run Verify Reload ← — → ▶ Preview ■ Stop ⛶ Full Screen

×

Intent→Code Code→Exec Intent→Exec

Raw JSON

Gate Status

I1Active Claim

W1Code Barcoded

W2Auto-Build

E1Build Exists

B1Valid Parent

C1Compose First

S1Alignment

S2Verification

26 Standards

Export

Download Barcoded Python Download Barcoded JavaScript Download JSON Packet Copy Current Barcode Copy Barcoded Source

Download

Download Project (.zip)

GitHub

Repo (user/name)

Token

Init Git Push to GitHub

Vercel

Token

Deploy to Vercel

Ship It

Ship It (Git + Deploy)

Ready

' +
                esc(JSON.stringify(data, null, 2)) + '<\/pre>';

            // If DOC- barcode, render content in Panel 2 Code tab
            if (barcode.startsWith('DOC-')) {
                const content = data.content || data.text || data.source_text || JSON.stringify(data, null, 2);
                const area = document.getElementById('cardArea');
                const emptyState = document.getElementById('emptyState');
                if (emptyState) emptyState.style.display = 'none';

                // Add document card to Panel 2
                const card = document.createElement('div');
                card.className = 'function-card unchecked';
                card.innerHTML =
                    '
' +
                    bcBadge(barcode) +
                    '' + esc(data.title || barcode) + '' +
                    '
' +
                    '
' +
                    renderMarkdown(content) + '
';
                area.prepend(card);

                // Switch to Code tab
                document.querySelectorAll('#p2-code,#p2-tools,#p2-versions,#p2-analytics,#p2-devtools').forEach(el => el.classList.remove('active'));
                document.getElementById('p2-code').classList.add('active');
                document.querySelectorAll('.panel-accumulator .panel-tab').forEach(t => t.classList.remove('active'));
                document.querySelectorAll('.panel-accumulator .panel-tab')[0].classList.add('active');
            }

            toast('Resolved: ' + barcode);
        } else {
            toast('Not found: ' + barcode, true);
        }
    } catch {
        toast('Lookup failed', true);
    }
}

/* Component 24: auto-check alignment after execution */

function switchP1Tab(tabId) {
    document.querySelectorAll('#p1-intent,#p1-atoms,#p1-domains').forEach(el => el.classList.remove('active'));
    document.getElementById('p1-' + tabId).classList.add('active');
    document.querySelectorAll('.panel-conversation .panel-tab').forEach(t => t.classList.remove('active'));
    event.target.classList.add('active');
    if (tabId === 'atoms') loadAtomStats();
    if (tabId === 'domains') loadDomains();
}

/* ═══════════════════════════
   BATCH 1: ATOM BANK BROWSER
   Components 1-10 (DOC-DA0B8F030CED)
   ═══════════════════════════ */

let atomSearchTimer = null;

/* Component 1: atom-search */
function debounceAtomSearch() {
    clearTimeout(atomSearchTimer);
    atomSearchTimer = setTimeout(searchAtoms, 300);
}

async function searchAtoms() {
    const query = document.getElementById('atomSearchInput').value.trim();
    const domain = document.getElementById('atomFilterDomain').value;
    if (!query && !domain) return;
    const results = document.getElementById('atomResults');
    results.innerHTML = '
Searching ' + (query ? esc(query) : esc(domain)) + '...
';

    // Primary: use Gate C1 search (searches code_atoms.db directly)
    try {
        const resp = await apiFetch('/api/platform/search-atoms', {
            method: 'POST',
            body: JSON.stringify({ intent: query || domain, code: query ? 'def ' + query + '(): pass' : '' })
        });
        if (resp.ok) {
            const data = await resp.json();
            if (data.matched_atoms && data.matched_atoms.length > 0) {
                results.innerHTML = '
' + data.match_count + ' atoms found
' +
                    data.matched_atoms.map(m => renderAtomCard({
                        qualified_name: m.qualified_name,
                        barcode: m.barcode,
                        source_code: m.source_code,
                        domain: '',
                        match_type: m.match_type
                    }, 'code')).join('');
                return;
            }
        }
    } catch {}

    // Fallback: word atoms
    if (query) {
        try {
            const resp2 = await fetch('/api/atoms/related/' + encodeURIComponent(query));
            if (resp2.ok) {
                const data2 = await resp2.json();
                const wordAtoms = data2.atoms || [];
                if (wordAtoms.length > 0) {
                    results.innerHTML = '
Word atoms (no code match)
' +
                        wordAtoms.map(a => renderAtomCard(a, 'word')).join('');
                    return;
                }
            }
        } catch {}
    }

    results.innerHTML = '
No atoms found for "' + esc(query || domain) + '"
';
}

/* Component 3: atom-card + Component 4: atom-detail + Component 5: atom-source-viewer */
function renderAtomCard(atom, type) {
    const name = atom.qualified_name || atom.word || 'unknown';
    const barcode = atom.barcode || '';
    const domain = atom.domain || '';
    const source = atom.source_code || atom.definition || '';
    const preview = source.split('\n').slice(0, 3).join('\n');
    const id = 'atom-' + (barcode || name).replace(/[^a-zA-Z0-9]/g, '');

    return '
' +
        '
' +
        bcBadge(barcode) +
        '' + esc(name) + '' +
        domainBadge(domain) +
        '
' +
        '
' + esc(source || 'No source available') + '
' +
        '
';
}

function toggleAtomDetail(id) {
    document.getElementById(id)?.classList.toggle('expanded');
}

/* Component 6: domain-browser */
async function loadDomains() {
    try {
        const resp = await fetch('/api/code/graph');
        if (!resp.ok) return;
        const data = await resp.json();
        const domains = data.domains || {};
        const list = document.getElementById('domainList');
        const sorted = Object.entries(domains).sort((a, b) => b[1] - a[1]);
        list.innerHTML = sorted.map(([d, c]) =>
            '
' +
            '' + esc(d) + '' +
            '' + c.toLocaleString() + '' +
            '
'
        ).join('');

        // Also populate the filter dropdown (Component 2)
        const select = document.getElementById('atomFilterDomain');
        select.innerHTML = 'All domains' +
            sorted.map(([d, c]) => '' + esc(d) + ' (' + c.toLocaleString() + ')').join('');
    } catch {}
}

function filterByDomain(domain) {
    document.getElementById('atomFilterDomain').value = domain;
    document.querySelectorAll('.domain-item').forEach(el => el.classList.remove('active'));
    event.target.closest('.domain-item')?.classList.add('active');
    switchP1Tab('atoms');
    // Trigger re-render of tabs
    document.querySelectorAll('#p1-intent,#p1-atoms,#p1-domains').forEach(el => el.classList.remove('active'));
    document.getElementById('p1-atoms').classList.add('active');
    document.querySelectorAll('.panel-conversation .panel-tab').forEach(t => t.classList.remove('active'));
    document.querySelectorAll('.panel-conversation .panel-tab')[1].classList.add('active');
    searchAtoms();
}

/* Component 7: barcode-lookup */
async function lookupBarcode() {
    const input = document.getElementById('barcodeLookupInput').value.trim();
    if (!input) return;
    const result = document.getElementById('barcodeLookupResult');
    result.innerHTML = '
Resolving...
';

    try {
        const resp = await fetch('/api/barcode/resolve/' + encodeURIComponent(input));
        if (resp.ok) {
            const data = await resp.json();
            result.innerHTML = '
' +
                esc(JSON.stringify(data, null, 2)) + '
';
        } else {
            result.innerHTML = '
Not found: ' + esc(input) + '
';
        }
    } catch {
        result.innerHTML = '
Lookup failed
';
    }
}

/* Component 8: composition-suggestions (wired to Gate C1) */
async function loadCompositionSuggestions(intentText) {
    const panel = document.getElementById('compositionResults');
    if (!intentText) return;
    panel.innerHTML = '
Searching dictionary...
';

    try {
        const resp = await apiFetch('/api/platform/search-atoms', {
            method: 'POST',
            body: JSON.stringify({ intent: intentText, code: '' })
        });
        if (resp.ok) {
            const data = await resp.json();
            if (data.matched_atoms && data.matched_atoms.length > 0) {
                panel.innerHTML = data.matched_atoms.map(m =>
                    '
' +
                    '' + esc(m.barcode) + '' +
                    '' + esc(m.qualified_name) + '' +
                    '' + esc(m.match_type) + '' +
                    '
'
                ).join('');
            } else {
                panel.innerHTML = '
No existing atoms match — new code needed
';
            }
        }
    } catch {
        panel.innerHTML = '
Search failed
';
    }
}

function copyAtomSource(barcode) {
    toast('Barcode copied: ' + barcode);
    navigator.clipboard?.writeText(barcode);
}

/* Component 9: atom-stats */
async function loadAtomStats() {
    try {
        const resp = await fetch('/api/code/graph');
        if (!resp.ok) return;
        const data = await resp.json();
        document.getElementById('statCodeAtoms').textContent = (data.total_atoms || 0).toLocaleString();
        document.getElementById('statBonds').textContent = (data.total_bonds || 0).toLocaleString();
        // Count functions from domains
        const totalFn = Object.values(data.domains || {}).reduce((a, b) => a + b, 0);
        document.getElementById('statFunctions').textContent = totalFn.toLocaleString();
    } catch {}
}

/* Component 10: atom-graph (bond list for selected atom) — rendered inside atom-card-bonds when expanded */

/* ═══════════════════════════
   BATCH 6: PROJECT MANAGEMENT
   Components 51-60 (DOC-918EDC28ECD8)
   ═══════════════════════════ */

/* Component 56: file-tree (hierarchical view) */
function renderFileTree(files) {
    if (!files || files.length === 0) return '
No files
';
    const tree = {};
    files.forEach(f => {
        const parts = f.path.split('/');
        let node = tree;
        parts.forEach((p, i) => {
            if (i === parts.length - 1) { node[p] = f; }
            else { node[p] = node[p] || {}; node = node[p]; }
        });
    });
    function renderNode(obj, depth) {
        return Object.entries(obj).map(([name, val]) => {
            if (val.path) {
                return '
' +
                    '📄' + esc(name) + '
';
            }
            return '
' +
                '📁' + esc(name) + '
' + renderNode(val, depth + 1);
        }).join('');
    }
    return renderNode(tree, 0);
}

/* Component 59: file-search */
async function searchFiles() {
    if (!currentProject) return;
    const query = prompt('Search file content:');
    if (!query) return;
    const resp = await apiFetch(API + '/projects/' + currentProject.id + '/files');
    if (!resp.ok) return;
    const files = await resp.json();
    const matches = [];
    for (const f of files) {
        const fResp = await apiFetch(API + '/projects/' + currentProject.id + '/files/' + encodeURIComponent(f.path));
        if (fResp.ok) {
            const data = await fResp.json();
            if (data.content && data.content.includes(query)) {
                matches.push(f.path);
            }
        }
    }
    if (matches.length > 0) {
        toast(matches.length + ' file(s) match: ' + matches.join(', '));
    } else { toast('No matches found', true); }
}

/* Component 60: project-stats */
async function loadProjectStats() {
    if (!currentProject) return '';
    const resp = await apiFetch(API + '/projects/' + currentProject.id + '/files');
    if (!resp.ok) return '';
    const files = await resp.json();
    const buildResp = await apiFetch(API + '/build/versions/' + currentProject.id);
    const builds = buildResp.ok ? await buildResp.json() : [];
    return '
' +
        '' + files.length + ' files' +
        '' + builds.length + ' builds' +
        '
';
}

/* ═══════════════════════════
   BATCH 7: AUTH & COLLABORATION
   Components 61-70 (DOC-8EFC18A7BB13)
   ═══════════════════════════ */

/* Component 67: presence-tooltip — already handled by title attr on dots */
/* Component 68: cursor-indicator — needs WebSocket, placeholder */

/* Component 70: session-indicator */
let sessionStartTime = Date.now();
function renderSessionIndicator() {
    const elapsed = Math.floor((Date.now() - sessionStartTime) / 1000);
    const min = Math.floor(elapsed / 60);
    const sec = elapsed % 60;
    return min + ':' + String(sec).padStart(2, '0');
}

/* ═══════════════════════════
   BATCH 8: ANALYTICS & MONITORING
   Components 71-80 (DOC-F1FD97353BBC)
   ═══════════════════════════ */

let sessionRounds = 0;
let sessionTokens = 0;
let sessionSearchHits = 0;
let sessionSearchTotal = 0;

/* Component 71: composition-rate-chart (simple bar) */
function compositionRateBar() {
    const total = sessionComposed + sessionGenerated;
    if (total === 0) return '
No builds yet
';
    const pct = Math.round((sessionComposed / total) * 100);
    return '
Composed: ' + pct + '% (' + sessionComposed + '/' + total + ')
' +
        '
' +
        '
';
}

/* Component 72: atom-growth-counter */
async function atomGrowthCounter() {
    try {
        const resp = await fetch('/api/code/graph');
        if (!resp.ok) return '—';
        const data = await resp.json();
        return '
' +
            (data.total_atoms || 0).toLocaleString() + '
' +
            '
code atoms
';
    } catch { return '—'; }
}

/* Component 73: build-history */
function buildHistoryList(chain) {
    if (!chain || chain.length === 0) return '
No builds
';
    return chain.slice(-10).reverse().map(v =>
        '
' +
        'v' + v.version_number + '' +
        bcBadge(v.bld_barcode) +
        '' + new Date(v.created_at * 1000).toLocaleTimeString() + '' +
        '
'
    ).join('');
}

/* Component 74: tool-usage-chart */
function toolUsageChart(toolsCalled) {
    if (!toolsCalled || toolsCalled.length === 0) return '';
    const counts = {};
    toolsCalled.forEach(t => { counts[t[0]] = (counts[t[0]] || 0) + 1; });
    const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]);
    const max = sorted[0][1];
    return sorted.map(([name, count]) =>
        '
' +
        '' + name + '' +
        '
' +
        '
' +
        '' + count + '' +
        '
'
    ).join('');
}

/* Component 75: tier-distribution */
function tierDistributionBars(tierProfile) {
    if (!tierProfile || Object.keys(tierProfile).length === 0) return '';
    const max = Math.max(...Object.values(tierProfile));
    return Object.entries(tierProfile).sort((a,b) => a[0] - b[0]).map(([tier, count]) =>
        '
' +
        tierBadge(parseInt(tier)) +
        '
' +
        '
' +
        '' + count + '' +
        '
'
    ).join('');
}

/* Component 78: session-stats */
function renderSessionStats() {
    return '
' +
        'Rounds: ' + sessionRounds + '' +
        'Session: ' + renderSessionIndicator() + '' +
        'Composed: ' + sessionComposed + '' +
        'Generated: ' + sessionGenerated + '' +
        '
';
}

/* Component 79: health-score */
async function loadHealthScore() {
    try {
        const resp = await fetch('/api/health');
        if (!resp.ok) return 'offline';
        const data = await resp.json();
        const score = data.health_score || data.status;
        return ' ' + (score || 'healthy');
    } catch { return ' offline'; }
}

/* ═══════════════════════════
   BATCH 9: EXPORT (mostly done in Batch 2)
   Components 81-90 (DOC-3C6F8414E3AF)
   ═══════════════════════════ */

/* Components 81-86: exportBarcoded() already built in Batch 2 */
/* Component 87-88: copyCurrentBarcode(), copyCurrentSource() already built */

/* Component 89: share-build (shareable URL with barcode) */
function shareBuild() {
    if (!currentProject) { toast('No project', true); return; }
    const url = window.location.origin + '/platform.html?project=' + currentProject.id;
    navigator.clipboard?.writeText(url);
    toast('Build URL copied');
}

/* Component 90: print-certificate */
function printCertificate() {
    if (!currentProject || !currentFile) { toast('No file selected', true); return; }
    const code = document.getElementById('codeInput')?.value || '';
    const bc = document.querySelector('.card-barcode')?.textContent || 'N/A';
    const bld = document.querySelector('.card-barcode.bld')?.textContent || 'N/A';
    const win = window.open('', '_blank');
    win.document.write('' +
        '
Barcode Verification Certificate
' +
        '
Project: ' + esc(currentProject.name) + '
' +
        '
File: ' + esc(currentFile.path) + '
' +
        '
Document: ' + esc(bc) + '
' +
        '
Build: ' + esc(bld) + '
' +
        '
Date: ' + new Date().toISOString() + '
' +
        '
' +
        '
' + esc(code.substring(0, 2000)) + '
' +
        '
Verified by SovrenAI Barcode Code Production Machine<\/p>' +
        '<\/body><\/html>');
    win.print();
}

/* ═══════════════════════════
   BATCH 10: DEVELOPER TOOLS
   Components 91-100 (DOC-F57042B4124B)
   ═══════════════════════════ */

/* Component 91: dev-console */
async function devConsoleQuery(query) {
    if (!query) { query = prompt('Dictionary search (e.g. "fibonacci", "celsius"):'); }
    if (!query) return;
    try {
        const resp = await apiFetch(API + '/search-atoms', {
            method: 'POST',
            body: JSON.stringify({ intent: query, code: '' })
        });
        if (resp.ok) {
            const data = await resp.json();
            return data;
        }
    } catch {}
    return null;
}

/* Component 92: network-monitor */
let networkLog = [];
const originalFetch = window.fetch;
window.fetch = async function(...args) {
    const url = typeof args[0] === 'string' ? args[0] : args[0]?.url || '';
    const method = args[1]?.method || 'GET';
    const start = Date.now();
    try {
        const resp = await originalFetch.apply(this, args);
        networkLog.push({ url: url.substring(0, 60), method, status: resp.status, ms: Date.now() - start, time: new Date().toLocaleTimeString() });
        if (networkLog.length > 50) networkLog.shift();
        return resp;
    } catch (e) {
        networkLog.push({ url: url.substring(0, 60), method, status: 'ERR', ms: Date.now() - start, time: new Date().toLocaleTimeString() });
        throw e;
    }
};

function renderNetworkLog() {
    return networkLog.slice(-15).reverse().map(n =>
        '
' +
        '' + n.time + '' +
        '' + n.status + '' +
        '' + n.method + '' +
        '' + esc(n.url) + '' +
        '' + n.ms + 'ms' +
        '
'
    ).join('');
}

/* Component 94: barcode-resolver */
async function resolveBarcode(barcode) {
    if (!barcode) { barcode = prompt('Enter barcode:'); }
    if (!barcode) return null;
    try {
        const resp = await fetch('/api/barcode/resolve/' + encodeURIComponent(barcode));
        if (resp.ok) return await resp.json();
    } catch {}
    return null;
}

/* Component 100: keyboard-shortcuts */
function showKeyboardShortcuts() {
    toast('Shortcuts: Enter=Submit | Tab=Indent | Ctrl+S=Save');
}

document.addEventListener('keydown', e => {
    if (e.ctrlKey && e.key === 's') { e.preventDefault(); autoSave(); toast('Saved'); }
    if (e.key === '?' && e.ctrlKey) { e.preventDefault(); showKeyboardShortcuts(); }
});

/* ── INIT ── */
checkAuth();
loadProjects();
loadDomains();