heaplens-cli 0.0.0-stage → 0.1.1

package/runtime/browser-ui/sources.cjs

@@ -0,0 +1,72 @@
+'use strict';
+const fs = require('node:fs/promises');
+const sync = require('node:fs');
+const path = require('node:path');
+const MAX = 256 * 1024;
+function classParts(value) {
+    if (typeof value !== 'string' || value.length > 1024)
+        throw Error('Invalid class name');
+    const parts = value.replace(/^class /, '').replace(/(?:\[\])+$/, '').split('.');
+    if (!parts.every(x => /^[\p{L}\p{Nl}\p{Sc}\p{Pc}][\p{L}\p{Nl}\p{Sc}\p{Pc}\p{Nd}\p{Mn}\p{Mc}]*$/u.test(x)))
+        throw Error('Invalid class name');
+    const simple = parts.at(-1), inner = simple.indexOf('$', 1);
+    parts[parts.length - 1] = (inner < 0 ? simple : simple.slice(0, inner)) + '.java';
+    return parts;
+}
+function contained(root, file) { return file === root || file.startsWith(root + path.sep); }
+class Sources {
+    constructor(roots) { this.roots = roots; this.files = null; }
+    async index() {
+        if (this.files)
+            return this.files;
+        const result = [];
+        let visited = 0;
+        for (const input of this.roots) {
+            const root = input;
+            if (await fs.realpath(root) !== root || !(await fs.stat(root)).isDirectory())
+                throw Error('Approved source root moved or is not a directory');
+            async function walk(dir) {
+                for await (const entry of await fs.opendir(dir)) {
+                    if (++visited > 50000)
+                        throw Error('Source scope is too large. Choose a narrower source directory.');
+                    if (entry.isSymbolicLink() || ['.git', 'node_modules', '.idea', 'target', 'build'].includes(entry.name))
+                        continue;
+                    const file = path.join(dir, entry.name);
+                    if (entry.isDirectory())
+                        await walk(file);
+                    else if (entry.isFile() && entry.name.endsWith('.java'))
+                        result.push({ root, rootIndex: thisRootIndex, file, label: path.relative(root, file) });
+                }
+            }
+            const thisRootIndex = this.roots.indexOf(input) + 1;
+            await walk(root);
+        }
+        this.files = result;
+        return result;
+    }
+    async find(name) { const suffix = classParts(name).join(path.sep); const matches = (await this.index()).filter(x => x.label === suffix || x.label.endsWith(path.sep + suffix)); if (matches.length > 20)
+        throw Error('Too many matching files. Choose narrower source roots.'); return matches; }
+    async read(target) {
+        const resolved = await fs.realpath(target.file);
+        if (!contained(target.root, resolved))
+            throw Error('Source moved outside approved root');
+        const h = await fs.open(resolved, sync.constants.O_RDONLY | (sync.constants.O_NOFOLLOW || 0));
+        try {
+            const st = await h.stat();
+            if (!st.isFile() || st.size > MAX)
+                throw Error('Source is unavailable or exceeds 256 KiB');
+            // Verify the handle still describes the confined file, not a swapped link.
+            const again = await fs.realpath(target.file), current = await fs.stat(again);
+            if (!contained(target.root, again) || current.ino !== st.ino || current.dev !== st.dev)
+                throw Error('Source changed during lookup');
+            const text = await h.readFile('utf8');
+            if (Buffer.byteLength(text) > MAX)
+                throw Error('Source exceeds 256 KiB');
+            return text;
+        }
+        finally {
+            await h.close();
+        }
+    }
+}
+module.exports = { Sources, classParts, contained };

package/runtime/browser-ui/telemetry-actions.cjs

@@ -0,0 +1,39 @@
+'use strict';
+// Focused optional observer: no engine objects, IDs or event bodies cross its sink.
+function observe(session, command, data) {
+    const telemetry=session.host.telemetry;
+    if (!telemetry || session.state==='closed') return;
+    const state=session.diagnosticState ||= {generation:-1,phase:'unknown',completed:-1};
+    if(command==='analysisProgress') {
+        if(state.generation!==session.generation) {
+            state.generation=session.generation;state.started=Date.now();
+            telemetry.track('analysis/started',{}, {fileSizeMB:session.file.size/1048576});
+        }
+        const phase=['loading','graph_building','graph_built','dominators'].includes(data.stage)?data.stage:'unknown';
+        if(phase!==state.phase){state.phase=phase;telemetry.track('analysis/phase',{phase});}
+    } else if(command==='analysisComplete' && state.completed!==session.generation) {
+        state.completed=session.generation;
+        const summary=data.summary||{};
+        telemetry.track('analysis/completed',{}, {durationMs:Math.min(86400000,Date.now()-state.started),objectCount:summary.total_instances||0,
+            classCount:summary.total_classes||0,heapSizeMB:(summary.total_heap_size||0)/1048576});
+    } else if(command==='serverCrashed') {
+        telemetry.track('error/serverCrashed',{phase:state.phase,errorType:'unknown'});
+    } else if(command==='analysisCancelled') telemetry.track('analysis/cancelled');
+    else if(command==='queryError') telemetry.track('query/failed',{phase:'query',errorType:'unknown'});
+    else if(command==='queryResult') telemetry.track('feature/queryExecuted');
+}
+function install(session) {
+    const actions={aiSend:'feature/chatMessage',openProjectSource:'feature/goToSource',fixWithAi:'feature/fixWithAi',explainObject:'feature/explainObject',
+        explainLeakSuspect:'feature/explainLeakSuspect',inspectObject:'feature/inspectObject',gcRootPath:'feature/gcRootPath',compareHeaps:'feature/compareHeaps',
+        exportHistogramCsv:'feature/export',copyReportText:'feature/export',exportCompareCsv:'feature/export',exportCompareMarkdown:'feature/export'};
+    for(const [command,event]of Object.entries(actions)) {
+        const action=session.commands.get(command);
+        if(action)session.commands.set(command,m=>{session.host.telemetry?.track(event);return action(m);});
+    }
+    session.commands.set('tabViewed',m=>session.host.telemetry?.track('feature/tabViewed',{tab:m.tab}));
+    const retry=session.commands.get('retryAnalysis');
+    session.commands.set('retryAnalysis',m=>{if(['failed','cancelled'].includes(session.state))session.host.telemetry?.track('analysis/retry');return retry(m);});
+    session.commands.set('telemetryOff',()=>{session.host.telemetry?.setLevel('off');session.emit('localActionStatus',{message:'Telemetry is off. Pending delivery was cleared.'});});
+    session.commands.set('reviewDiagnostics',()=>session.emit('diagnosticReport',{text:JSON.stringify(session.host.telemetry?.report()||{},null,2)}));
+}
+module.exports={observe,install};

package/runtime/browser-ui/waste-actions.cjs

@@ -0,0 +1,20 @@
+'use strict';
+const { requestId } = require('./guards.cjs');
+module.exports.install = session => {
+    session.commands.set('calculateWaste', async m => {
+        const id = requestId(m), original = session.raw;
+        try {
+            const waste = await session.engine('get_waste_analysis', {});
+            if (session.raw !== original) return;
+            session.raw.waste_analysis = waste;
+            if (session.snapshot) {
+                const totals = Object.fromEntries(['total_wasted_bytes', 'waste_percentage', 'duplicate_string_wasted_bytes', 'empty_collection_wasted_bytes', 'over_allocated_wasted_bytes', 'boxed_primitive_wasted_bytes'].map(k => [k, waste[k]]));
+                session.snapshot = { ...session.snapshot, waste_analysis: totals };
+                session.host.changed();
+            }
+            session.emit('wasteResult', { requestId: id, wasteAnalysis: waste });
+        } catch {
+            session.emit('wasteError', { requestId: id, error: 'Waste analysis unavailable. Retry after retained analysis completes.' });
+        }
+    });
+};

package/runtime/package.json

@@ -0,0 +1 @@
+{"version":"0.1.1"}

package/runtime/telemetry/contract.cjs

@@ -0,0 +1,31 @@
+'use strict';
+const schema = require('./contract.json');
+const own = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+function record(name, context, properties = {}, measurements = {}) {
+    if (!properties || typeof properties!=='object' || Array.isArray(properties) || !measurements || typeof measurements!=='object' || Array.isArray(measurements)) return null;
+    if (!own(schema.events, name) || !schema.hosts.includes(context.host) ||
+        !schema.platforms.includes(context.os) || !schema.architectures.includes(context.arch)) return null;
+    const event = schema.events[name], props = {} , metrics = {};
+    for (const [key, value] of Object.entries(properties)) {
+        if (!event.properties.includes(key) || !schema.enums[key].includes(value)) return null;
+        props[key] = value;
+    }
+    for (const [key, value] of Object.entries(measurements)) {
+        if (!event.measurements.includes(key)) return null;
+        const bound = schema.metrics[key];
+        if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > bound.max) return null;
+        metrics[key] = Math.floor(value / bound.quantum) * bound.quantum;
+    }
+    const version = /^(?:unknown|[0-9]{1,4}\.[0-9]{1,4}\.[0-9]{1,4}(?:-[a-z0-9.-]{1,24})?)$/.test(context.version) ? context.version : 'unknown';
+    return { name, category: event.category, properties: {
+        schemaVersion: String(schema.schemaVersion), host: context.host, version, os: context.os, arch: context.arch, ...props
+    }, measurements: metrics };
+}
+function envelope(event, time = new Date().toISOString()) {
+    return { ver: 1, name: 'Microsoft.ApplicationInsights.Event', time, iKey: schema.instrumentationKey,
+        tags: {}, data: { baseType: 'EventData', baseData: { ver: 2, name: 'heaplens/' + event.name,
+            properties: event.properties, measurements: event.measurements } } };
+}
+const platform = value => schema.platforms.includes(value) ? value : 'unknown';
+const architecture = value => ({ aarch64:'arm64', arm64:'arm64', x86_64:'x64', amd64:'x64', x64:'x64' }[value] || 'unknown');
+module.exports = { schema, record, envelope, platform, architecture };

package/runtime/telemetry/contract.json

@@ -0,0 +1,60 @@
+{
+  "schemaVersion": 1,
+  "endpoint": "https://eastus2-3.in.applicationinsights.azure.com/v2/track",
+  "instrumentationKey": "963d68d0-40ec-4dcb-ad11-48c8abacd67c",
+  "hosts": ["vscode", "intellij", "cli", "browser"],
+  "platforms": ["darwin", "win32", "linux", "unknown"],
+  "architectures": ["arm64", "x64", "unknown"],
+  "enums": {
+    "errorType": ["timeout", "memory_error", "parse", "not_found", "permission", "server_spawn", "cancelled", "killed", "pipe_broken", "protocol", "unknown"],
+    "phase": ["input", "loading", "graph_building", "graph_built", "dominators", "query", "output", "server_start", "unknown"],
+    "signal": ["none", "SIGKILL", "SIGTERM", "SIGSEGV", "SIGABRT", "SIGBUS", "other"],
+    "exitCode": ["0", "1", "2", "3", "4", "5", "6", "137", "139", "unknown"],
+    "keyword": ["select", "group_by", "where", "order_by", "instances", "retained", "count", "other"],
+    "tab": ["overview", "histogram", "domtree", "leaks", "waste", "source", "query", "compare", "timeline", "monitor", "chat", "unknown"],
+    "provider": ["anthropic", "openai", "gemini", "deepseek", "mistral", "groq", "xai", "together", "openrouter", "ollama"],
+    "format": ["json", "report", "csv", "compare-markdown", "compare-csv", "text"],
+    "tier": ["workspace", "source-jar", "decompiled", "dependency", "none"],
+    "status": ["diff-opened", "already-fixed", "source-not-found", "cancelled", "error"],
+    "command": ["default", "analyze", "leaks", "explain", "query", "compare"],
+    "ruleId": ["heap-growth", "new-leak-suspects", "class-explosion", "resolved-leaks"],
+    "severity": ["warning", "info"]
+  },
+  "metrics": {
+    "fileSizeMB": {"max": 1048576, "quantum": 64},
+    "heapSizeMB": {"max": 1048576, "quantum": 64},
+    "durationMs": {"max": 86400000, "quantum": 100},
+    "elapsedMinutes": {"max": 1440, "quantum": 1},
+    "objectCount": {"max": 1000000000000, "quantum": 1000},
+    "classCount": {"max": 10000000, "quantum": 100},
+    "leakSuspectCount": {"max": 10000000, "quantum": 10},
+    "consecutiveFailures": {"max": 100, "quantum": 1}
+  },
+  "events": {
+    "analysis/started": {"category": "usage", "properties": [], "measurements": ["fileSizeMB"]},
+    "analysis/phase": {"category": "usage", "properties": ["phase"], "measurements": []},
+    "analysis/completed": {"category": "usage", "properties": [], "measurements": ["durationMs", "objectCount", "classCount", "leakSuspectCount", "heapSizeMB"]},
+    "analysis/cancelled": {"category": "usage", "properties": [], "measurements": []},
+    "analysis/longRunning": {"category": "usage", "properties": [], "measurements": ["elapsedMinutes"]},
+    "analysis/failed": {"category": "error", "properties": ["errorType", "phase"], "measurements": ["durationMs"]},
+    "analysis/retry": {"category": "usage", "properties": [], "measurements": []},
+    "analysis/recovered": {"category": "usage", "properties": [], "measurements": []},
+    "error/serverCrashed": {"category": "error", "properties": ["exitCode", "signal", "phase", "errorType"], "measurements": []},
+    "error/heartbeatFailed": {"category": "error", "properties": [], "measurements": ["consecutiveFailures"]},
+    "query/failed": {"category": "error", "properties": ["errorType", "phase"], "measurements": []},
+    "feature/queryExecuted": {"category": "usage", "properties": ["keyword"], "measurements": []},
+    "feature/tabViewed": {"category": "usage", "properties": ["tab"], "measurements": []},
+    "feature/chatMessage": {"category": "usage", "properties": ["provider"], "measurements": []},
+    "feature/copilotChat": {"category": "usage", "properties": ["command"], "measurements": []},
+    "feature/goToSource": {"category": "usage", "properties": ["tier"], "measurements": []},
+    "feature/fixWithAi": {"category": "usage", "properties": ["status"], "measurements": []},
+    "feature/compareHeaps": {"category": "usage", "properties": [], "measurements": []},
+    "feature/export": {"category": "usage", "properties": ["format"], "measurements": []},
+    "feature/gcRootPath": {"category": "usage", "properties": [], "measurements": []},
+    "feature/inspectObject": {"category": "usage", "properties": [], "measurements": []},
+    "feature/explainObject": {"category": "usage", "properties": [], "measurements": []},
+    "feature/explainLeakSuspect": {"category": "usage", "properties": [], "measurements": []},
+    "alert/fired": {"category": "usage", "properties": ["ruleId", "severity"], "measurements": []},
+    "alert/viewComparison": {"category": "usage", "properties": ["ruleId"], "measurements": []}
+  }
+}

package/runtime/telemetry/node.cjs

@@ -0,0 +1,62 @@
+'use strict';
+const https = require('node:https');
+const { schema, record, envelope } = require('./contract.cjs');
+
+// No SDK, automatic exceptions, identity tags, redirects, disk queue or retries.
+function azureSend(body, done) {
+    let finished = false, deadline, request;
+    const finish = ok => { if (!finished) { finished = true; clearTimeout(deadline); done(ok); } };
+    try {
+        request = https.request(schema.endpoint, { method: 'POST', headers: {
+            'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body)
+        } }, response => { response.on('error',()=>finish(false));response.on('end',()=>finish(response.statusCode === 200));response.resume(); });
+        request.on('error', () => finish(false));
+        deadline = setTimeout(() => { request.destroy(); finish(false); }, 1000);
+        deadline.unref();
+        request.end(body);
+    } catch { finish(false); }
+    return () => { request?.destroy(); finish(false); };
+}
+
+class Telemetry {
+    constructor({ context, level = 'off', disabled = false, send = azureSend }) {
+        this.context = context; this.disabled = disabled; this.send = send;
+        this.level = 'off'; this.queue = []; this.recent = []; this.job = null;
+        this.submitted = 0; this.accepted = 0; this.dropped = 0; this.generation = 0;
+        this.setLevel(level);
+    }
+    setLevel(level) {
+        const next = !this.disabled && ['off','error','all'].includes(level) ? level : 'off';
+        if (next === this.level) return;
+        this.level = next; this.generation++; this.queue.length = 0;
+        const retired = this.job; this.job = null; retired?.abort?.();
+    }
+    track(name, properties, measurements) {
+        try {
+            const event = record(name, this.context, properties, measurements);
+            if (!event) return false;
+            this.recent.push(event); if (this.recent.length > 20) this.recent.shift();
+            if (this.level === 'off' || (this.level === 'error' && event.category !== 'error')) return true;
+            if (this.queue.length >= 16 || this.submitted + this.queue.length >= 256) { this.dropped++; return true; }
+            this.queue.push(event); queueMicrotask(() => this.pump()); return true;
+        } catch { return false; }
+    }
+    pump() {
+        if (this.job || !this.queue.length || this.level === 'off') return;
+        const event = this.queue.shift(), job = { generation: this.generation, abort: null };
+        this.job = job; this.submitted++;
+        const finish = accepted => {
+            if (this.job !== job || job.generation !== this.generation) return;
+            if (accepted) this.accepted++;
+            this.job = null; queueMicrotask(() => this.pump());
+        };
+        try { job.abort = this.send(JSON.stringify(envelope(event)), finish); }
+        catch { finish(false); }
+    }
+    report() { return { schemaVersion: 1, level: this.level, submitted: this.submitted, accepted: this.accepted,
+        queued: this.queue.length, dropped: this.dropped,
+        note: 'Local allowlisted records. HTTP acceptance is not proof of Azure portal visibility. No stable user/session IDs; network services may process IP addresses.',
+        events: JSON.parse(JSON.stringify(this.recent)) }; }
+    dispose() { this.setLevel('off'); this.recent.length = 0; }
+}
+module.exports = { Telemetry, azureSend };