notoken-core 1.6.0 → 2.0.0

package/dist/nlp/vocabularyBuilder.js

@@ -0,0 +1,224 @@
+/**
+ * Vocabulary Builder — learns vocabulary from Wikidata lookups.
+ *
+ * After every successful Wikidata entity lookup, this module:
+ *   1. Extracts instanceOf labels and maps them to intent domains
+ *   2. Collects aliases as synonyms for future matching
+ *   3. Adds related concepts to the concept router map
+ *   4. Persists learned vocabulary to ~/.notoken/learned-vocabulary.json
+ *
+ * On startup, loads learned vocabulary and merges it into the
+ * concept router's CONCEPT_DOMAINS so future queries benefit.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { USER_HOME } from "../utils/paths.js";
+import { mergeConceptDomains } from "./conceptRouter.js";
+const VOCAB_FILE = resolve(USER_HOME, "learned-vocabulary.json");
+// ─── Default domain mapping rules ─────────────────────────────────────────
+// When we encounter an instanceOf label from Wikidata, map it to likely
+// intent domains. This is the heuristic that turns Wikidata types into
+// actionable routing information.
+const INSTANCE_OF_TO_DOMAINS = {
+    // Software / services
+    "web server": ["service.status", "service.restart"],
+    "reverse proxy": ["service.status", "service.restart"],
+    "http server": ["service.status", "service.restart"],
+    "web framework": ["knowledge.lookup"],
+    "application server": ["service.status", "service.restart"],
+    "database management system": ["service.status", "service.restart"],
+    "relational database management system": ["service.status", "service.restart"],
+    "nosql database": ["service.status", "service.restart"],
+    "message broker": ["service.status", "service.restart"],
+    "caching system": ["service.status", "service.restart"],
+    "search engine software": ["service.status", "service.restart"],
+    // Container / orchestration
+    "container orchestrator": ["docker.ps", "docker.restart"],
+    "containerization": ["docker.ps", "docker.restart"],
+    "container platform": ["docker.ps", "docker.restart"],
+    // Programming languages
+    "programming language": ["knowledge.lookup"],
+    "scripting language": ["knowledge.lookup"],
+    "markup language": ["knowledge.lookup"],
+    // Operating systems
+    "operating system": ["system.kernel", "system.hostname"],
+    "linux distribution": ["system.kernel", "package.audit"],
+    // Networking
+    "network protocol": ["network.connections", "network.ports"],
+    "communication protocol": ["network.connections"],
+    // Version control
+    "version control system": ["git.status", "git.branch"],
+    // Package management
+    "package manager": ["package.audit"],
+    // General software
+    "free software": ["knowledge.lookup"],
+    "open-source software": ["knowledge.lookup"],
+    "software": ["knowledge.lookup"],
+};
+// ─── In-memory state ──────────────────────────────────────────────────────
+let vocabulary = {
+    concepts: {},
+    domainMappings: {},
+    learnedAt: new Date().toISOString(),
+};
+let loaded = false;
+// ─── Persistence ──────────────────────────────────────────────────────────
+function readVocabFile() {
+    try {
+        if (existsSync(VOCAB_FILE)) {
+            const raw = JSON.parse(readFileSync(VOCAB_FILE, "utf-8"));
+            if (raw && typeof raw === "object" && raw.concepts && raw.domainMappings) {
+                return raw;
+            }
+        }
+    }
+    catch { /* corrupted file — start fresh */ }
+    return null;
+}
+function saveVocabFile() {
+    try {
+        mkdirSync(USER_HOME, { recursive: true });
+        vocabulary.learnedAt = new Date().toISOString();
+        writeFileSync(VOCAB_FILE, JSON.stringify(vocabulary, null, 2));
+    }
+    catch { /* best-effort persistence */ }
+}
+// ─── Core logic ───────────────────────────────────────────────────────────
+/**
+ * Enrich vocabulary from a Wikidata entity.
+ *
+ * Called after every successful Wikidata lookup. Extracts:
+ *   - instanceOf labels → domain mappings
+ *   - aliases → concept synonyms
+ *   - related concepts → concept router entries
+ */
+export function enrichVocabularyFromWiki(entity) {
+    ensureLoaded();
+    const label = entity.label.toLowerCase();
+    const existingAliases = vocabulary.concepts[label] ?? [];
+    const newAliases = new Set(existingAliases);
+    // 1. Collect aliases as synonyms
+    for (const alias of entity.aliases) {
+        const lower = alias.toLowerCase();
+        if (lower !== label) {
+            newAliases.add(lower);
+        }
+    }
+    // 2. Add instanceOf labels as synonyms too (they describe what it is)
+    for (const inst of entity.instanceOf) {
+        const lower = inst.toLowerCase();
+        if (lower !== label) {
+            newAliases.add(lower);
+        }
+    }
+    vocabulary.concepts[label] = [...newAliases];
+    // 3. Map instanceOf labels to intent domains
+    const entityDomains = new Set();
+    for (const inst of entity.instanceOf) {
+        const lower = inst.toLowerCase();
+        // Check our built-in heuristic mapping
+        const mapped = INSTANCE_OF_TO_DOMAINS[lower];
+        if (mapped) {
+            for (const d of mapped)
+                entityDomains.add(d);
+            // Persist the mapping so it's available next time
+            if (!vocabulary.domainMappings[lower]) {
+                vocabulary.domainMappings[lower] = [...mapped];
+            }
+        }
+        // Also check previously learned domain mappings
+        const learned = vocabulary.domainMappings[lower];
+        if (learned) {
+            for (const d of learned)
+                entityDomains.add(d);
+        }
+    }
+    // 4. Merge into concept router: entity label + aliases → discovered domains
+    const domainsArray = [...entityDomains];
+    if (domainsArray.length > 0) {
+        // Map the entity label itself
+        mergeConceptDomains({ [label]: domainsArray });
+        // Map each alias to the same domains
+        for (const alias of newAliases) {
+            mergeConceptDomains({ [alias]: domainsArray });
+        }
+    }
+    // 5. Add related concepts to concept router with the same domains (lower weight)
+    if (domainsArray.length > 0) {
+        for (const rel of entity.related) {
+            const lower = rel.toLowerCase();
+            mergeConceptDomains({ [lower]: domainsArray });
+        }
+    }
+    // Persist
+    saveVocabFile();
+}
+/**
+ * Load learned vocabulary from disk and merge into the concept router.
+ *
+ * Should be called on startup so that previously learned vocabulary
+ * is available for intent routing from the first query.
+ */
+export function loadLearnedVocabulary() {
+    const saved = readVocabFile();
+    if (saved) {
+        vocabulary = saved;
+    }
+    // Merge all learned concepts into the concept router
+    const toMerge = {};
+    for (const [label, aliases] of Object.entries(vocabulary.concepts)) {
+        // Determine domains for this label from domain mappings
+        const domains = resolveDomains(label, aliases);
+        if (domains.length > 0) {
+            toMerge[label] = domains;
+            for (const alias of aliases) {
+                toMerge[alias] = domains;
+            }
+        }
+    }
+    if (Object.keys(toMerge).length > 0) {
+        mergeConceptDomains(toMerge);
+    }
+    loaded = true;
+}
+/**
+ * Get the current enriched concepts map (merged vocabulary).
+ *
+ * Returns a combined view of hardcoded concepts and learned vocabulary.
+ */
+export function getEnrichedConcepts() {
+    ensureLoaded();
+    return {
+        concepts: { ...vocabulary.concepts },
+        domainMappings: { ...vocabulary.domainMappings },
+        learnedAt: vocabulary.learnedAt,
+    };
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────
+function ensureLoaded() {
+    if (!loaded) {
+        loadLearnedVocabulary();
+    }
+}
+/**
+ * Resolve domains for a concept by checking its instanceOf-style labels
+ * against both the built-in heuristic map and learned domain mappings.
+ */
+function resolveDomains(label, aliases) {
+    const domains = new Set();
+    // Check if the label itself is a known instanceOf category
+    const directMap = INSTANCE_OF_TO_DOMAINS[label] ?? vocabulary.domainMappings[label];
+    if (directMap) {
+        for (const d of directMap)
+            domains.add(d);
+    }
+    // Check aliases — some may be instanceOf labels
+    for (const alias of aliases) {
+        const aliasMap = INSTANCE_OF_TO_DOMAINS[alias] ?? vocabulary.domainMappings[alias];
+        if (aliasMap) {
+            for (const d of aliasMap)
+                domains.add(d);
+        }
+    }
+    return [...domains];
+}

package/dist/nlp/wikidata.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Wikidata Knowledge Base.
+ *
+ * When the NLP parser encounters unknown nouns, queries Wikidata to:
+ *   1. Identify what the entity is (person, software, company, concept)
+ *   2. Pull key facts (description, instance-of, subclass-of)
+ *   3. Build semantic relationships (related topics, categories)
+ *   4. Cache results locally for offline use
+ *
+ * Uses the Wikidata REST API (no auth needed).
+ * Results are cached in ~/.notoken/wikidata-cache.json
+ */
+export interface WikiEntity {
+    id: string;
+    label: string;
+    description: string;
+    aliases: string[];
+    instanceOf: string[];
+    subclassOf: string[];
+    related: string[];
+    url: string;
+    wikipedia?: string;
+    cachedAt: string;
+}
+export interface WikiLookupResult {
+    found: boolean;
+    entity?: WikiEntity;
+    suggestions?: Array<{
+        id: string;
+        label: string;
+        description: string;
+    }>;
+    error?: string;
+}
+/**
+ * Search Wikidata for an entity by name.
+ */
+export declare function searchWikidata(query: string): Promise<WikiLookupResult>;
+export declare function formatWikiEntity(entity: WikiEntity): string;
+export declare function formatWikiSuggestions(suggestions: Array<{
+    id: string;
+    label: string;
+    description: string;
+}>): string;
+/**
+ * Look up unknown nouns via Wikidata.
+ * Called when the parser can't match an intent and has unknown words.
+ */
+export declare function lookupUnknownNouns(words: string[]): Promise<WikiEntity[]>;

package/dist/nlp/wikidata.js

@@ -0,0 +1,228 @@
+/**
+ * Wikidata Knowledge Base.
+ *
+ * When the NLP parser encounters unknown nouns, queries Wikidata to:
+ *   1. Identify what the entity is (person, software, company, concept)
+ *   2. Pull key facts (description, instance-of, subclass-of)
+ *   3. Build semantic relationships (related topics, categories)
+ *   4. Cache results locally for offline use
+ *
+ * Uses the Wikidata REST API (no auth needed).
+ * Results are cached in ~/.notoken/wikidata-cache.json
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { USER_HOME } from "../utils/paths.js";
+import { enrichVocabularyFromWiki } from "./vocabularyBuilder.js";
+const CACHE_FILE = resolve(USER_HOME, "wikidata-cache.json");
+const CACHE_TTL = 7 * 24 * 3600_000; // 7 days
+const WIKIDATA_API = "https://www.wikidata.org/w/api.php";
+const SEARCH_URL = "https://www.wikidata.org/w/api.php?action=wbsearchentities&format=json&language=en&limit=3&search=";
+const c = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m", magenta: "\x1b[35m",
+};
+let cache = {};
+function loadCache() {
+    try {
+        if (existsSync(CACHE_FILE)) {
+            cache = JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+        }
+    }
+    catch {
+        cache = {};
+    }
+}
+function saveCache() {
+    try {
+        mkdirSync(USER_HOME, { recursive: true });
+        // Prune expired entries
+        const now = Date.now();
+        for (const [key, entry] of Object.entries(cache)) {
+            if (now - entry.timestamp > CACHE_TTL)
+                delete cache[key];
+        }
+        writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+    }
+    catch { }
+}
+function getCached(key) {
+    loadCache();
+    const entry = cache[key.toLowerCase()];
+    if (!entry)
+        return null;
+    if (Date.now() - entry.timestamp > CACHE_TTL)
+        return null;
+    return entry.entity;
+}
+function setCache(key, entity) {
+    cache[key.toLowerCase()] = { entity, timestamp: Date.now() };
+    saveCache();
+}
+// ─── API ───────────────────────────────────────────────────────────────────
+async function fetchJson(url) {
+    try {
+        const response = await fetch(url, {
+            signal: AbortSignal.timeout(8000),
+            headers: { "User-Agent": "NoToken-CLI/1.0 (https://notoken.sh)" },
+        });
+        if (!response.ok)
+            return null;
+        return response.json();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Search Wikidata for an entity by name.
+ */
+export async function searchWikidata(query) {
+    // Check cache first
+    const cached = getCached(query);
+    if (cached)
+        return { found: true, entity: cached };
+    // Search Wikidata
+    const searchData = await fetchJson(`${SEARCH_URL}${encodeURIComponent(query)}`);
+    if (!searchData?.search?.length) {
+        return { found: false, error: "No results found on Wikidata" };
+    }
+    const suggestions = searchData.search.map(s => ({
+        id: s.id, label: s.label, description: s.description,
+    }));
+    // Fetch full entity data for top result
+    const topId = searchData.search[0].id;
+    const entity = await fetchEntity(topId, searchData.search[0].label, searchData.search[0].description);
+    if (entity) {
+        setCache(query, entity);
+        // Enrich vocabulary from this lookup for future NLP matching
+        try {
+            enrichVocabularyFromWiki(entity);
+        }
+        catch { }
+        return { found: true, entity, suggestions };
+    }
+    return { found: false, suggestions };
+}
+/**
+ * Fetch full entity details from Wikidata by Q-number.
+ */
+async function fetchEntity(qid, label, description) {
+    const url = `${WIKIDATA_API}?action=wbgetentities&format=json&ids=${qid}&props=labels|descriptions|aliases|claims|sitelinks&languages=en`;
+    const data = await fetchJson(url);
+    if (!data?.entities?.[qid])
+        return null;
+    const e = data.entities[qid];
+    const claims = e.claims ?? {};
+    // Extract instance-of (P31) and subclass-of (P279) labels
+    const instanceOf = await resolveClaimLabels(claims["P31"]);
+    const subclassOf = await resolveClaimLabels(claims["P279"]);
+    // Get related entities from "part of" (P361), "has use" (P366), "field of work" (P101)
+    const relatedClaims = [
+        ...(claims["P361"] ?? []), // part of
+        ...(claims["P366"] ?? []), // has use
+        ...(claims["P101"] ?? []), // field of work
+        ...(claims["P1535"] ?? []), // used by
+    ];
+    const related = await resolveClaimLabels(relatedClaims);
+    const aliases = (e.aliases?.en ?? []).map(a => a.value).slice(0, 10);
+    const wikipedia = e.sitelinks?.enwiki?.url;
+    return {
+        id: qid,
+        label: e.labels?.en?.value ?? label,
+        description: e.descriptions?.en?.value ?? description,
+        aliases,
+        instanceOf,
+        subclassOf,
+        related,
+        url: `https://www.wikidata.org/wiki/${qid}`,
+        wikipedia,
+        cachedAt: new Date().toISOString(),
+    };
+}
+async function resolveClaimLabels(claims) {
+    if (!claims?.length)
+        return [];
+    const qids = [];
+    for (const c of claims.slice(0, 8)) {
+        const val = c.mainsnak?.datavalue?.value;
+        if (typeof val === "object" && val && "id" in val && val.id) {
+            qids.push(val.id);
+        }
+    }
+    if (qids.length === 0)
+        return [];
+    // Batch fetch labels
+    const url = `${WIKIDATA_API}?action=wbgetentities&format=json&ids=${qids.join("|")}&props=labels&languages=en`;
+    const data = await fetchJson(url);
+    if (!data?.entities)
+        return [];
+    return qids
+        .map(q => data.entities?.[q]?.labels?.en?.value)
+        .filter((l) => !!l);
+}
+// ─── Formatting ────────────────────────────────────────────────────────────
+export function formatWikiEntity(entity) {
+    const lines = [];
+    lines.push(`${c.bold}${c.cyan}${entity.label}${c.reset}`);
+    lines.push(`${c.dim}${entity.description}${c.reset}\n`);
+    if (entity.instanceOf.length > 0) {
+        lines.push(`  ${c.bold}Type:${c.reset} ${entity.instanceOf.join(", ")}`);
+    }
+    if (entity.subclassOf.length > 0) {
+        lines.push(`  ${c.bold}Category:${c.reset} ${entity.subclassOf.join(", ")}`);
+    }
+    if (entity.aliases.length > 0) {
+        lines.push(`  ${c.bold}Also known as:${c.reset} ${entity.aliases.join(", ")}`);
+    }
+    if (entity.related.length > 0) {
+        lines.push(`  ${c.bold}Related:${c.reset} ${entity.related.join(", ")}`);
+    }
+    lines.push("");
+    if (entity.wikipedia) {
+        lines.push(`  ${c.dim}Wikipedia: ${entity.wikipedia}${c.reset}`);
+    }
+    lines.push(`  ${c.dim}Wikidata: ${entity.url}${c.reset}`);
+    return lines.join("\n");
+}
+export function formatWikiSuggestions(suggestions) {
+    const lines = [];
+    lines.push(`${c.bold}Did you mean:${c.reset}\n`);
+    for (const s of suggestions) {
+        lines.push(`  ${c.cyan}${s.label}${c.reset} — ${c.dim}${s.description}${c.reset}`);
+    }
+    return lines.join("\n");
+}
+// ─── Integration with NLP ──────────────────────────────────────────────────
+/**
+ * Look up unknown nouns via Wikidata.
+ * Called when the parser can't match an intent and has unknown words.
+ */
+export async function lookupUnknownNouns(words) {
+    const results = [];
+    // Filter to likely nouns (capitalized, or multi-char words not in common stop words)
+    const candidates = words.filter(w => w.length >= 3 &&
+        !STOP_WORDS.has(w.toLowerCase()));
+    for (const word of candidates.slice(0, 3)) {
+        const result = await searchWikidata(word);
+        if (result.found && result.entity) {
+            results.push(result.entity);
+        }
+    }
+    return results;
+}
+const STOP_WORDS = new Set([
+    "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "do", "does", "did", "will", "would", "shall",
+    "should", "may", "might", "must", "can", "could", "and", "but", "or",
+    "if", "then", "else", "when", "where", "how", "what", "which", "who",
+    "that", "this", "these", "those", "it", "its", "my", "your", "his",
+    "her", "our", "their", "not", "no", "yes", "all", "any", "each",
+    "every", "some", "many", "much", "more", "most", "very", "just",
+    "about", "above", "after", "again", "before", "below", "between",
+    "both", "down", "during", "for", "from", "here", "in", "into",
+    "of", "off", "on", "out", "over", "own", "same", "so", "than",
+    "then", "there", "through", "to", "too", "under", "until", "up",
+    "with", "check", "show", "get", "list", "find", "run", "start",
+    "stop", "restart", "install", "please", "help", "me", "tell",
+]);

package/dist/policy/confirm.d.ts

@@ -1,2 +1,12 @@
 export declare function askForConfirmation(message: string): Promise<boolean>;
+/**
+ * Require the user to type an exact phrase to confirm a dangerous action.
+ * Returns true only if the typed text matches exactly.
+ */
+export declare function askForStrictConfirmation(message: string, requiredPhrase: string): Promise<boolean>;
+/**
+ * Ask with extended responses: y/n plus control flow.
+ * Returns: "yes" | "no" | "all" | "stop"
+ */
+export declare function askWithControl(message: string): Promise<"yes" | "no" | "all" | "stop">;
 export declare function askForChoice(message: string, choices: string[]): Promise<string | null>;

package/dist/policy/confirm.js

@@ -10,6 +10,45 @@ export async function askForConfirmation(message) {
         rl.close();
     }
 }
+/**
+ * Require the user to type an exact phrase to confirm a dangerous action.
+ * Returns true only if the typed text matches exactly.
+ */
+export async function askForStrictConfirmation(message, requiredPhrase) {
+    const rl = readline.createInterface({ input, output });
+    try {
+        const answer = await rl.question(`${message}\n  Type "${requiredPhrase}" to confirm: `);
+        return answer.trim() === requiredPhrase;
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Ask with extended responses: y/n plus control flow.
+ * Returns: "yes" | "no" | "all" | "stop"
+ */
+export async function askWithControl(message) {
+    const rl = readline.createInterface({ input, output });
+    try {
+        const answer = await rl.question(`${message} [y/N/all/stop] `);
+        const trimmed = answer.trim().toLowerCase();
+        // Yes
+        if (/^y(es)?$/.test(trimmed))
+            return "yes";
+        // All / do everything / keep going / clean everything
+        if (/^(all|yes.?all|do.?all|everything|clean.?(all|everything)|keep.?going|do.?it|go.?ahead)$/.test(trimmed))
+            return "all";
+        // Stop / abort / quit / enough / don't / no more / stop right there
+        if (/^(stop|abort|quit|enough|no.?more|that.?s?.?enough|stop.?right.?there|cancel|done|don.?t|nah|exit)$/.test(trimmed))
+            return "stop";
+        // Default: no
+        return "no";
+    }
+    finally {
+        rl.close();
+    }
+}
 export async function askForChoice(message, choices) {
     const rl = readline.createInterface({ input, output });
     try {

package/dist/policy/safety.js

@@ -1,4 +1,4 @@
-import { getIntentDef } from "../utils/config.js";
+import { getIntentDef, loadRules } from "../utils/config.js";
 export function validateIntent(intent) {
     const def = getIntentDef(intent.intent);
     if (!def)
@@ -9,13 +9,15 @@ export function validateIntent(intent) {
             errors.push(`Missing required field: ${fieldName}`);
         }
     }
-    // Check allowlist if defined
+    // Check allowlist — services from rules.json serviceAliases are always allowed
     if (def.allowlist && def.allowlist.length > 0) {
+        const rules = loadRules();
+        const knownServices = new Set([...def.allowlist, ...Object.keys(rules.serviceAliases)]);
         for (const [fieldName, fieldDef] of Object.entries(def.fields)) {
             if (fieldDef.type === "service" && intent.fields[fieldName]) {
                 const value = intent.fields[fieldName];
-                if (!def.allowlist.includes(value)) {
-                    errors.push(`${fieldName} "${value}" is not in the allowlist: ${def.allowlist.join(", ")}`);
+                if (!knownServices.has(value)) {
+                    errors.push(`${fieldName} "${value}" is not in the allowlist: ${[...knownServices].join(", ")}`);
                 }
             }
         }

package/dist/utils/aliases.d.ts

@@ -0,0 +1,5 @@
+export declare function loadAliases(): Record<string, string>;
+export declare function resolveAlias(text: string): string;
+export declare function saveAlias(name: string, command: string): void;
+export declare function removeAlias(name: string): boolean;
+export declare function listAliases(): Record<string, string>;

package/dist/utils/aliases.js

@@ -0,0 +1,39 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { USER_HOME } from "./paths.js";
+const ALIASES_FILE = resolve(USER_HOME, "aliases.json");
+function ensureDir() {
+    if (!existsSync(USER_HOME))
+        mkdirSync(USER_HOME, { recursive: true });
+}
+export function loadAliases() {
+    try {
+        const raw = readFileSync(ALIASES_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export function resolveAlias(text) {
+    const aliases = loadAliases();
+    return aliases[text] ?? text;
+}
+export function saveAlias(name, command) {
+    ensureDir();
+    const aliases = loadAliases();
+    aliases[name] = command;
+    writeFileSync(ALIASES_FILE, JSON.stringify(aliases, null, 2) + "\n", "utf-8");
+}
+export function removeAlias(name) {
+    const aliases = loadAliases();
+    if (!(name in aliases))
+        return false;
+    delete aliases[name];
+    ensureDir();
+    writeFileSync(ALIASES_FILE, JSON.stringify(aliases, null, 2) + "\n", "utf-8");
+    return true;
+}
+export function listAliases() {
+    return loadAliases();
+}