@vascend/talos 0.1.0

package/dist/vascend/code-graph-memory.d.ts

@@ -0,0 +1,38 @@
+import { type CodeEdge, type CodeEvent, type CodeImport, type CodeSymbol, type FeatureArea, type TestMapping } from "./code-graph-types.js";
+import { type CodeEventSink } from "./code-events.js";
+export type SourceReader = (file: string) => string | null;
+export interface CodeGraphMemoryOptions {
+    readonly sink?: CodeEventSink;
+    readonly reader?: SourceReader;
+    readonly now?: () => number;
+}
+export declare class CodeGraphMemory {
+    private readonly files;
+    private readonly sink;
+    private readonly reader;
+    private readonly clock;
+    constructor(opts?: CodeGraphMemoryOptions);
+    indexFile(file: string, source: string): readonly CodeEvent[];
+    indexFromDisk(file: string): readonly CodeEvent[];
+    removeFile(file: string): readonly CodeEvent[];
+    private emitAll;
+    recordTestResult(testFile: string, passed: boolean, opts?: {
+        readonly message?: string;
+        readonly covers?: readonly string[];
+    }): CodeEvent;
+    symbols(): readonly CodeSymbol[];
+    symbol(id: string): CodeSymbol | null;
+    symbolsOf(file: string): readonly CodeSymbol[];
+    apiOf(file: string): readonly string[];
+    importsOf(file: string): readonly CodeImport[];
+    indexedFiles(): readonly string[];
+    dependencyGraph(): readonly CodeEdge[];
+    dependents(file: string): readonly string[];
+    testMappings(): readonly TestMapping[];
+    coveredBy(testFile: string): readonly string[];
+    testsFor(sourceFile: string): readonly string[];
+    private mappingFor;
+    featureAreas(): readonly FeatureArea[];
+    private resolveImport;
+    private matchIndexed;
+}

package/dist/vascend/code-graph-memory.js

@@ -0,0 +1,334 @@
+// CodeGraphMemory (metodo Danilov, Memory OS).
+//
+// Indice in-memory della STRUTTURA del repository:
+//   - simboli (per id e per file)
+//   - import / dipendenze (grafo orientato file -> file)
+//   - API pubbliche per file (export)
+//   - test mapping (test -> sorgenti coperti, derivato dagli import)
+//   - feature areas (raggruppamenti per cartella di dominio)
+//
+// Quando un file viene (ri)indicizzato, fa il DIFF con lo stato precedente ed
+// emette gli eventi del dominio code verso un CodeEventSink iniettabile:
+//   code.file.touched, code.symbol.changed, code.import.added,
+//   code.api.changed, code.contract.changed.
+// I risultati dei test producono code.test.failed / code.test.passed.
+//
+// Modulo di SOLA INDICIZZAZIONE: legge sorgenti (passati come stringa o via un
+// reader iniettabile) e aggiorna l'indice; non scrive su disco. La persistenza
+// degli eventi e' responsabilita' del sink. Zero dipendenze a runtime.
+import { featureAreaOf, } from "./code-graph-types.js";
+import {} from "./code-events.js";
+import { isTestFile, parseSource, publicApiOf } from "./code-parser.js";
+export class CodeGraphMemory {
+    files = new Map();
+    sink;
+    reader;
+    clock;
+    constructor(opts = {}) {
+        this.sink = opts.sink ?? null;
+        this.reader = opts.reader ?? null;
+        this.clock = opts.now ?? (() => Date.now());
+    }
+    // --- indicizzazione -------------------------------------------------------
+    // (Ri)indicizza un file dal suo sorgente, diffando con lo stato precedente ed
+    // emettendo gli eventi conseguenti. Ritorna gli eventi emessi (per test).
+    indexFile(file, source) {
+        const norm = normPath(file);
+        const parsed = parseSource(norm, source);
+        const prev = this.files.get(norm);
+        const at = this.clock();
+        const area = featureAreaOf(norm);
+        const events = [];
+        const next = {
+            file: norm,
+            symbols: new Map(parsed.symbols.map((s) => [s.id, s])),
+            imports: parsed.imports,
+            api: publicApiOf(parsed),
+            isTest: parsed.isTest,
+        };
+        // 1) file.touched sempre (un file e' stato (ri)visto).
+        events.push({ type: "code.file.touched", file: norm, area, at });
+        // 2) diff simboli: added / modified (firma) / removed.
+        const prevSymbols = prev?.symbols ?? new Map();
+        for (const [id, sym] of next.symbols) {
+            const before = prevSymbols.get(id);
+            if (!before) {
+                events.push({ type: "code.symbol.changed", file: norm, symbol: sym, change: "added", area, at });
+                // contratto: se il simbolo nasce gia' pubblico con firma.
+                if (sym.exported && sym.signature) {
+                    events.push({ type: "code.contract.changed", file: norm, symbol: sym, area, at });
+                }
+            }
+            else if (before.signature !== sym.signature || before.exported !== sym.exported) {
+                events.push({ type: "code.symbol.changed", file: norm, symbol: sym, change: "modified", area, at });
+                if (sym.exported && before.signature !== sym.signature) {
+                    events.push({
+                        type: "code.contract.changed",
+                        file: norm,
+                        symbol: sym,
+                        previousSignature: before.signature,
+                        area,
+                        at,
+                    });
+                }
+            }
+        }
+        for (const [id, before] of prevSymbols) {
+            if (!next.symbols.has(id)) {
+                events.push({ type: "code.symbol.changed", file: norm, symbol: before, change: "removed", area, at });
+            }
+        }
+        // 3) import nuovi.
+        const prevModules = new Set((prev?.imports ?? []).map((i) => i.module));
+        for (const imp of next.imports) {
+            if (!prevModules.has(imp.module)) {
+                events.push({ type: "code.import.added", file: norm, import: imp, area, at });
+            }
+        }
+        // 4) api.changed: diff dell'insieme di export.
+        const beforeApi = new Set(prev?.api ?? []);
+        const afterApi = new Set(next.api);
+        const apiAdded = [...afterApi].filter((n) => !beforeApi.has(n));
+        const apiRemoved = [...beforeApi].filter((n) => !afterApi.has(n));
+        if (prev && (apiAdded.length || apiRemoved.length)) {
+            events.push({ type: "code.api.changed", file: norm, apiAdded, apiRemoved, area, at });
+        }
+        else if (!prev && afterApi.size > 0) {
+            // primo index di un file con API pubblica: registra l'API come "aggiunta".
+            events.push({ type: "code.api.changed", file: norm, apiAdded: [...afterApi], apiRemoved: [], area, at });
+        }
+        this.files.set(norm, next);
+        this.emitAll(events);
+        return events;
+    }
+    // Indicizza un file leggendolo col reader iniettato. No-op se assente.
+    indexFromDisk(file) {
+        if (!this.reader)
+            return [];
+        const src = this.reader(normPath(file));
+        if (src == null)
+            return [];
+        return this.indexFile(file, src);
+    }
+    // Rimuove un file dall'indice ed emette removed per i suoi simboli.
+    removeFile(file) {
+        const norm = normPath(file);
+        const prev = this.files.get(norm);
+        if (!prev)
+            return [];
+        const at = this.clock();
+        const area = featureAreaOf(norm);
+        const events = [];
+        for (const sym of prev.symbols.values()) {
+            events.push({ type: "code.symbol.changed", file: norm, symbol: sym, change: "removed", area, at });
+        }
+        if (prev.api.length) {
+            events.push({ type: "code.api.changed", file: norm, apiAdded: [], apiRemoved: [...prev.api], area, at });
+        }
+        this.files.delete(norm);
+        this.emitAll(events);
+        return events;
+    }
+    emitAll(events) {
+        if (!this.sink)
+            return;
+        for (const e of events) {
+            try {
+                this.sink.emit(e);
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+    // --- risultati test -------------------------------------------------------
+    // Registra l'esito di un test ed emette code.test.failed / code.test.passed.
+    // `covers` opzionale: se assente, viene derivato dal test mapping (import).
+    recordTestResult(testFile, passed, opts = {}) {
+        const norm = normPath(testFile);
+        const at = this.clock();
+        const covers = opts.covers ?? this.coveredBy(norm);
+        const area = featureAreaOf(norm);
+        const event = passed
+            ? { type: "code.test.passed", file: norm, testFile: norm, covers, area, at }
+            : { type: "code.test.failed", file: norm, testFile: norm, covers, message: opts.message ?? "", area, at };
+        this.emitAll([event]);
+        return event;
+    }
+    // --- query / viste --------------------------------------------------------
+    // Tutti i simboli indicizzati (ordine di file, poi di riga).
+    symbols() {
+        const out = [];
+        for (const fs of this.files.values())
+            out.push(...fs.symbols.values());
+        return out.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+    }
+    // Simbolo per id (es. "src/foo.ts#bar"), o null.
+    symbol(id) {
+        for (const fs of this.files.values()) {
+            const s = fs.symbols.get(id);
+            if (s)
+                return s;
+        }
+        return null;
+    }
+    // Simboli definiti in un file.
+    symbolsOf(file) {
+        const fs = this.files.get(normPath(file));
+        return fs ? [...fs.symbols.values()] : [];
+    }
+    // API pubblica (export) di un file.
+    apiOf(file) {
+        return this.files.get(normPath(file))?.api ?? [];
+    }
+    // Import di un file.
+    importsOf(file) {
+        return this.files.get(normPath(file))?.imports ?? [];
+    }
+    // File indicizzati.
+    indexedFiles() {
+        return [...this.files.keys()].sort();
+    }
+    // Grafo delle dipendenze: archi file -> file (import relativi risolti a path
+    // di file indicizzati). Gli import esterni (pacchetti) non producono archi.
+    dependencyGraph() {
+        const out = [];
+        const seen = new Set();
+        for (const fs of this.files.values()) {
+            for (const imp of fs.imports) {
+                if (imp.external)
+                    continue;
+                const to = this.resolveImport(fs.file, imp.module);
+                if (!to)
+                    continue;
+                const key = `${fs.file}->${to}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                out.push({ from: fs.file, to });
+            }
+        }
+        return out;
+    }
+    // File che dipendono (importano) dal file dato (dipendenze inverse).
+    dependents(file) {
+        const target = normPath(file);
+        const out = new Set();
+        for (const e of this.dependencyGraph()) {
+            if (e.to === target)
+                out.add(e.from);
+        }
+        return [...out].sort();
+    }
+    // Test mapping: per ogni file di test, i sorgenti che copre (via import) e i
+    // simboli sorgente referenziati nel test.
+    testMappings() {
+        const out = [];
+        for (const fs of this.files.values()) {
+            if (!fs.isTest)
+                continue;
+            out.push(this.mappingFor(fs));
+        }
+        return out.sort((a, b) => a.testFile.localeCompare(b.testFile));
+    }
+    // Sorgenti coperti da un file di test (path relativi risolti).
+    coveredBy(testFile) {
+        const fs = this.files.get(normPath(testFile));
+        if (!fs || !fs.isTest)
+            return [];
+        return this.mappingFor(fs).covers;
+    }
+    // Test che coprono un file sorgente (mappa inversa).
+    testsFor(sourceFile) {
+        const target = normPath(sourceFile);
+        const out = new Set();
+        for (const m of this.testMappings()) {
+            if (m.covers.includes(target))
+                out.add(m.testFile);
+        }
+        return [...out].sort();
+    }
+    mappingFor(fs) {
+        const covers = new Set();
+        const symbols = new Set();
+        for (const imp of fs.imports) {
+            if (imp.external)
+                continue;
+            const to = this.resolveImport(fs.file, imp.module);
+            if (!to)
+                continue;
+            covers.add(to);
+            // simboli importati dal sorgente coperto
+            const api = new Set(this.apiOf(to));
+            for (const name of imp.names) {
+                if (api.has(name))
+                    symbols.add(`${to}#${name}`);
+            }
+        }
+        return { testFile: fs.file, covers: [...covers].sort(), symbols: [...symbols].sort() };
+    }
+    // Feature areas: raggruppa i file indicizzati per cartella di dominio.
+    featureAreas() {
+        const byArea = new Map();
+        for (const file of this.files.keys()) {
+            const id = featureAreaOf(file);
+            const list = byArea.get(id) ?? [];
+            list.push(file);
+            byArea.set(id, list);
+        }
+        return [...byArea.entries()]
+            .map(([id, files]) => ({ id, label: id, files: files.sort() }))
+            .sort((a, b) => a.id.localeCompare(b.id));
+    }
+    // Risoluzione di un import relativo a un path di file indicizzato. Prova le
+    // estensioni TS/JS e l'index di cartella. Ritorna null se non risolvibile a
+    // un file noto (gli archi esistono solo verso file indicizzati).
+    resolveImport(fromFile, module) {
+        if (module.startsWith(".")) {
+            const baseDir = dirOf(fromFile);
+            const raw = joinPath(baseDir, module);
+            return this.matchIndexed(raw);
+        }
+        return null;
+    }
+    matchIndexed(rawNoExt) {
+        // .js -> prova la controparte .ts (sorgente) e poi .js.
+        const candidates = [];
+        const base = rawNoExt.replace(/\.[cm]?[jt]sx?$/, "");
+        const exts = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+        for (const ext of exts)
+            candidates.push(base + ext);
+        for (const ext of exts)
+            candidates.push(joinPath(rawNoExt, "index" + ext));
+        // anche il path cosi' com'e' (se gia' indicizzato con estensione)
+        candidates.unshift(rawNoExt);
+        for (const c of candidates) {
+            const n = normPath(c);
+            if (this.files.has(n))
+                return n;
+        }
+        return null;
+    }
+}
+// --- helper path (puri, no node:path per restare leggeri/testabili) --------
+function normPath(p) {
+    return p.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function dirOf(file) {
+    const norm = normPath(file);
+    const i = norm.lastIndexOf("/");
+    return i < 0 ? "" : norm.slice(0, i);
+}
+// Risolve "base" + "./rel" o "../rel" in un path normalizzato senza ".." .
+function joinPath(base, rel) {
+    const parts = (base ? base.split("/") : []).filter(Boolean);
+    for (const seg of normPath(rel).split("/")) {
+        if (seg === "" || seg === ".")
+            continue;
+        if (seg === "..")
+            parts.pop();
+        else
+            parts.push(seg);
+    }
+    return parts.join("/");
+}

package/dist/vascend/code-graph-runtime.d.ts

@@ -0,0 +1,19 @@
+import type { ToolRegistry } from "../tools/registry.js";
+export interface CodeGraphToolObservation {
+    readonly toolName: string;
+    readonly input: Readonly<Record<string, unknown>>;
+    readonly output: string;
+    readonly isError: boolean;
+    readonly cwd: string;
+    readonly sessionDir: string;
+    readonly scopeId: string;
+}
+export interface CodeGraphObservationResult {
+    readonly indexed: boolean;
+    readonly file?: string;
+    readonly events?: number;
+    readonly reason?: "unsupported" | "tool-error" | "outside-project" | "not-source" | "too-large" | "unchanged" | "unreadable";
+}
+export declare function installCodeGraphRuntime(registry: ToolRegistry): void;
+export declare function observeCodeGraphToolResult(observation: CodeGraphToolObservation): CodeGraphObservationResult;
+export declare function resetCodeGraphRuntimes(): void;

package/dist/vascend/code-graph-runtime.js

@@ -0,0 +1,190 @@
+// Runtime bridge tra i tool di filesystem e CodeGraphMemory.
+//
+// Il grafo strutturale esisteva gia', ma nessun percorso di produzione lo
+// alimentava. Questo modulo osserva soltanto tool di lettura/scrittura conclusi
+// con successo, indicizza file sorgente confinati nella cwd e persiste gli
+// eventi nel MemoryStore consumato dal Context Window Compiler.
+//
+// Best effort per costruzione: un errore dell'indice non cambia mai l'esito del
+// tool e non puo' interrompere la chat.
+import { createHash } from "node:crypto";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { CodeGraphMemory } from "./code-graph-memory.js";
+import { MemoryStoreCodeEventSink } from "./code-events.js";
+import { normalizeMcpToolResult, textFromMcpToolResult } from "../mcp/protocol.js";
+const SOURCE_EXTENSIONS = new Set([
+    ".ts", ".tsx", ".mts", ".cts",
+    ".js", ".jsx", ".mjs", ".cjs",
+]);
+const MAX_SOURCE_BYTES = 2 * 1024 * 1024;
+const MAX_RUNTIMES = 16;
+const OBSERVED_TOOLS = new Set(["read_file", "write_file", "edit_file"]);
+const WRAPPED = Symbol("talos.code-graph-runtime");
+const runtimes = new Map();
+// Decora i tool filesystem gia' presenti nel registro. Il wrapper mantiene il
+// relativo stato direct/deferred e viene attraversato anche da tool_invoke,
+// che recupera lo stesso ToolRegistry. Installazioni ripetute sono no-op.
+export function installCodeGraphRuntime(registry) {
+    for (const name of OBSERVED_TOOLS) {
+        const original = registry.get(name);
+        if (!original || isWrapped(original))
+            continue;
+        const deferred = registry.isDeferred(name);
+        const wrapped = {
+            ...original,
+            handler: async (input, ctx) => {
+                const output = await original.handler(input, ctx);
+                const textOutput = textFromMcpToolResult(normalizeMcpToolResult(output));
+                const scopeId = ctx.roomStoreId ?? ctx.sessionId;
+                if (ctx.sessionDir && scopeId) {
+                    observeCodeGraphToolResult({
+                        toolName: name,
+                        input,
+                        output: textOutput,
+                        isError: false,
+                        cwd: ctx.cwd,
+                        sessionDir: ctx.sessionDir,
+                        scopeId,
+                    });
+                }
+                return output;
+            },
+        };
+        Object.defineProperty(wrapped, WRAPPED, { value: true });
+        registry.register(wrapped, deferred);
+    }
+}
+// Osserva un risultato tool e aggiorna il grafo caldo. Non lancia mai.
+export function observeCodeGraphToolResult(observation) {
+    try {
+        if (!OBSERVED_TOOLS.has(observation.toolName)) {
+            return { indexed: false, reason: "unsupported" };
+        }
+        if (observation.isError || outputLooksFailed(observation.output)) {
+            return { indexed: false, reason: "tool-error" };
+        }
+        const args = toolArguments(observation.input);
+        const rawPath = stringArg(args, "path", "file", "file_path");
+        if (!rawPath)
+            return { indexed: false, reason: "unreadable" };
+        const target = confinedSource(observation.cwd, rawPath);
+        if (!target)
+            return { indexed: false, reason: "outside-project" };
+        if (!SOURCE_EXTENSIONS.has(target.extension)) {
+            return { indexed: false, file: target.relativePath, reason: "not-source" };
+        }
+        const stat = statSync(target.absolutePath);
+        if (!stat.isFile())
+            return { indexed: false, file: target.relativePath, reason: "unreadable" };
+        if (stat.size > MAX_SOURCE_BYTES) {
+            return { indexed: false, file: target.relativePath, reason: "too-large" };
+        }
+        const source = readFileSync(target.absolutePath, "utf8");
+        const digest = createHash("sha1").update(source).digest("hex");
+        const state = runtimeFor(observation);
+        if (state.hashes.get(target.relativePath) === digest) {
+            return { indexed: false, file: target.relativePath, reason: "unchanged" };
+        }
+        const events = state.graph.indexFile(target.relativePath, source);
+        state.hashes.set(target.relativePath, digest);
+        state.lastUsed = Date.now();
+        return { indexed: true, file: target.relativePath, events: events.length };
+    }
+    catch {
+        return { indexed: false, reason: "unreadable" };
+    }
+}
+// Solo per test e teardown di host embedded.
+export function resetCodeGraphRuntimes() {
+    runtimes.clear();
+}
+function runtimeFor(observation) {
+    const root = canonicalRoot(observation.cwd);
+    const key = `${root}\u0000${observation.sessionDir}\u0000${observation.scopeId}`;
+    const current = runtimes.get(key);
+    if (current) {
+        current.lastUsed = Date.now();
+        return current;
+    }
+    const state = {
+        graph: new CodeGraphMemory({
+            sink: MemoryStoreCodeEventSink.open(observation.sessionDir, observation.scopeId),
+        }),
+        hashes: new Map(),
+        lastUsed: Date.now(),
+    };
+    runtimes.set(key, state);
+    trimRuntimes();
+    return state;
+}
+function trimRuntimes() {
+    if (runtimes.size <= MAX_RUNTIMES)
+        return;
+    const oldest = [...runtimes.entries()]
+        .sort((a, b) => a[1].lastUsed - b[1].lastUsed || a[0].localeCompare(b[0]))[0];
+    if (oldest)
+        runtimes.delete(oldest[0]);
+}
+function canonicalRoot(cwd) {
+    try {
+        return realpathSync(cwd);
+    }
+    catch {
+        return resolve(cwd);
+    }
+}
+function confinedSource(cwd, rawPath) {
+    try {
+        const root = canonicalRoot(cwd);
+        const requested = resolve(root, rawPath);
+        const absolutePath = realpathSync(requested);
+        const rel = relative(root, absolutePath);
+        if (!rel || rel === "." || isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`))
+            return null;
+        const relativePath = rel.replace(/\\/g, "/");
+        const match = /\.[^.\/]+$/.exec(relativePath.toLowerCase());
+        return { absolutePath, relativePath, extension: match?.[0] ?? "" };
+    }
+    catch {
+        return null;
+    }
+}
+function toolArguments(input) {
+    if (typeof input["path"] === "string" || typeof input["file"] === "string" || typeof input["file_path"] === "string") {
+        return input;
+    }
+    const nested = input["args"] ?? input["arguments"] ?? input["parameters"] ?? input["input"];
+    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+        return nested;
+    }
+    if (typeof nested === "string") {
+        try {
+            const parsed = JSON.parse(nested);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Un wrapper non interpretabile non deve influire sul tool principale.
+        }
+    }
+    return input;
+}
+function stringArg(input, ...keys) {
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return "";
+}
+function outputLooksFailed(output) {
+    const normalized = output.trim().toLowerCase();
+    return /^(errore|eccezione|bloccato)\b/.test(normalized)
+        || normalized.includes("rifiutata dall'utente")
+        || normalized.includes("rifiutato dall'utente");
+}
+function isWrapped(tool) {
+    return Boolean(tool[WRAPPED]);
+}

package/dist/vascend/code-graph-types.d.ts

@@ -0,0 +1,58 @@
+export type SymbolKind = "function" | "class" | "interface" | "type" | "enum" | "const" | "variable" | "method" | "unknown";
+export interface CodeSymbol {
+    readonly id: string;
+    readonly name: string;
+    readonly kind: SymbolKind;
+    readonly file: string;
+    readonly exported: boolean;
+    readonly line: number;
+    readonly signature: string;
+}
+export interface CodeImport {
+    readonly file: string;
+    readonly module: string;
+    readonly names: readonly string[];
+    readonly external: boolean;
+}
+export interface CodeEdge {
+    readonly from: string;
+    readonly to: string;
+}
+export interface TestMapping {
+    readonly testFile: string;
+    readonly covers: readonly string[];
+    readonly symbols: readonly string[];
+}
+export interface FeatureArea {
+    readonly id: string;
+    readonly label: string;
+    readonly files: readonly string[];
+}
+export interface ParsedFile {
+    readonly file: string;
+    readonly symbols: readonly CodeSymbol[];
+    readonly imports: readonly CodeImport[];
+    readonly isTest: boolean;
+}
+export type CodeEventType = "code.symbol.changed" | "code.file.touched" | "code.import.added" | "code.api.changed" | "code.contract.changed" | "code.test.failed" | "code.test.passed";
+export type SymbolChange = "added" | "modified" | "removed";
+export interface CodeEvent {
+    readonly type: CodeEventType;
+    readonly file: string;
+    readonly symbol?: CodeSymbol;
+    readonly change?: SymbolChange;
+    readonly previousSignature?: string;
+    readonly import?: CodeImport;
+    readonly apiAdded?: readonly string[];
+    readonly apiRemoved?: readonly string[];
+    readonly testFile?: string;
+    readonly covers?: readonly string[];
+    readonly message?: string;
+    readonly area?: string;
+    readonly note?: string;
+    readonly at: number;
+}
+export declare function symbolId(file: string, name: string): string;
+export declare function codeActionLabel(type: CodeEventType): string;
+export declare function isPublicName(name: string): boolean;
+export declare function featureAreaOf(file: string): string;