@praeviso/code-env-switch 0.1.1 → 0.1.3

package/bin/commands/launch.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLaunch = runLaunch;
+/**
+ * Launch codex/claude with session binding
+ */
+const fs = require("fs");
+const path = require("path");
+const child_process_1 = require("child_process");
+const constants_1 = require("../constants");
+const type_1 = require("../profile/type");
+const usage_1 = require("../usage");
+const claude_1 = require("../statusline/claude");
+const codex_1 = require("../statusline/codex");
+const SESSION_BINDING_POLL_MS = 1000;
+const SESSION_BINDING_START_GRACE_MS = 5000;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function collectSessionFiles(root) {
+    if (!root || !fs.existsSync(root))
+        return [];
+    const files = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        let entries = [];
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith("."))
+                continue;
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+                files.push(full);
+            }
+        }
+    }
+    return files;
+}
+function readFirstJsonLine(filePath) {
+    let fd = null;
+    try {
+        fd = fs.openSync(filePath, "r");
+        const buffer = Buffer.alloc(64 * 1024);
+        const bytes = fs.readSync(fd, buffer, 0, buffer.length, 0);
+        if (bytes <= 0)
+            return null;
+        const text = buffer.slice(0, bytes).toString("utf8");
+        const line = text.split(/\r?\n/)[0];
+        if (!line)
+            return null;
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}
+function parseCodexFilenameInfo(filePath) {
+    const base = path.basename(filePath);
+    const match = base.match(/(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-([0-9a-fA-F-]+)\.jsonl$/);
+    if (!match) {
+        return { timestamp: null, timestampMs: null, sessionId: null };
+    }
+    const [, date, hour, minute, second, sessionId] = match;
+    const timestamp = `${date}T${hour}:${minute}:${second}`;
+    const parsedMs = new Date(timestamp).getTime();
+    return {
+        timestamp,
+        timestampMs: Number.isNaN(parsedMs) ? null : parsedMs,
+        sessionId: sessionId ? String(sessionId) : null,
+    };
+}
+function readSessionMeta(filePath, type) {
+    const first = readFirstJsonLine(filePath);
+    if (!isRecord(first))
+        return null;
+    if (type === "codex") {
+        const fromName = parseCodexFilenameInfo(filePath);
+        const payload = isRecord(first.payload) ? first.payload : null;
+        const ts = payload && payload.timestamp ? payload.timestamp : first.timestamp;
+        const timestamp = ts ? String(ts) : fromName.timestamp;
+        return {
+            filePath,
+            sessionId: payload && payload.id
+                ? String(payload.id)
+                : fromName.sessionId
+                    ? String(fromName.sessionId)
+                    : null,
+            timestamp,
+            fileTimestampMs: fromName.timestampMs,
+            cwd: payload && payload.cwd ? String(payload.cwd) : null,
+        };
+    }
+    return {
+        filePath,
+        sessionId: first.sessionId ? String(first.sessionId) : null,
+        timestamp: first.timestamp ? String(first.timestamp) : null,
+        fileTimestampMs: null,
+        cwd: first.cwd ? String(first.cwd) : null,
+    };
+}
+function getSessionCandidateTimestamp(meta, stat) {
+    const times = [];
+    if (Number.isFinite(stat.mtimeMs))
+        times.push(stat.mtimeMs);
+    if (meta.timestamp) {
+        const tsMs = new Date(meta.timestamp).getTime();
+        if (Number.isFinite(tsMs))
+            times.push(tsMs);
+    }
+    if (Number.isFinite(meta.fileTimestampMs))
+        times.push(meta.fileTimestampMs);
+    if (times.length === 0)
+        return null;
+    return Math.max(...times);
+}
+function findLatestUnboundSessionMeta(root, type, bound, minTimestampMs, cwd, skipFiles) {
+    const files = collectSessionFiles(root);
+    let bestMeta = null;
+    let bestTs = Number.NEGATIVE_INFINITY;
+    let bestCwdMatch = false;
+    for (const filePath of files) {
+        if (bound.byFile.has(filePath))
+            continue;
+        if (skipFiles && skipFiles.has(filePath))
+            continue;
+        let stat = null;
+        try {
+            stat = fs.statSync(filePath);
+        }
+        catch {
+            continue;
+        }
+        if (!stat || !stat.isFile())
+            continue;
+        const meta = readSessionMeta(filePath, type) || {
+            filePath,
+            sessionId: null,
+            timestamp: null,
+            fileTimestampMs: null,
+            cwd: null,
+        };
+        if (meta.sessionId && bound.byId.has(meta.sessionId))
+            continue;
+        const tsMs = getSessionCandidateTimestamp(meta, stat);
+        if (tsMs === null || Number.isNaN(tsMs))
+            continue;
+        if (minTimestampMs !== null && tsMs < minTimestampMs)
+            continue;
+        const cwdMatch = Boolean(cwd && meta.cwd && meta.cwd === cwd);
+        if (!bestMeta ||
+            (cwdMatch && !bestCwdMatch) ||
+            (cwdMatch === bestCwdMatch && tsMs > bestTs)) {
+            bestMeta = meta;
+            bestTs = tsMs;
+            bestCwdMatch = cwdMatch;
+        }
+    }
+    return bestMeta;
+}
+function getProfileEnv(type) {
+    const suffix = type.toUpperCase();
+    const key = process.env[`CODE_ENV_PROFILE_KEY_${suffix}`] || null;
+    const name = process.env[`CODE_ENV_PROFILE_NAME_${suffix}`] || key;
+    return { key, name };
+}
+function writeCodexAuthFromEnv() {
+    const apiKey = process.env.OPENAI_API_KEY;
+    try {
+        fs.mkdirSync(path.dirname(constants_1.CODEX_AUTH_PATH), { recursive: true });
+    }
+    catch {
+        // ignore
+    }
+    const authJson = apiKey === null || apiKey === undefined || apiKey === ""
+        ? "null"
+        : JSON.stringify({ OPENAI_API_KEY: String(apiKey) });
+    try {
+        fs.writeFileSync(constants_1.CODEX_AUTH_PATH, `${authJson}\n`, "utf8");
+    }
+    catch {
+        // ignore
+    }
+}
+function parseBooleanEnv(value) {
+    if (value === undefined)
+        return null;
+    const normalized = String(value).trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized))
+        return true;
+    if (["0", "false", "no", "off"].includes(normalized))
+        return false;
+    return null;
+}
+function isStatuslineEnabled(type) {
+    if (!process.stdout.isTTY || process.env.TERM === "dumb")
+        return false;
+    const disable = parseBooleanEnv(process.env.CODE_ENV_STATUSLINE_DISABLE);
+    if (disable === true)
+        return false;
+    const typeFlag = parseBooleanEnv(process.env[`CODE_ENV_STATUSLINE_${type.toUpperCase()}`]);
+    if (typeFlag !== null)
+        return typeFlag;
+    const genericFlag = parseBooleanEnv(process.env.CODE_ENV_STATUSLINE);
+    if (genericFlag !== null)
+        return genericFlag;
+    return true;
+}
+async function ensureClaudeStatuslineConfig(config, enabled) {
+    await (0, claude_1.ensureClaudeStatusline)(config, enabled);
+}
+async function runLaunch(config, configPath, target, args) {
+    const type = (0, type_1.normalizeType)(target);
+    if (!type) {
+        throw new Error(`Unknown launch target: ${target}`);
+    }
+    if (type === "codex") {
+        writeCodexAuthFromEnv();
+    }
+    const { key: profileKey, name: profileName } = getProfileEnv(type);
+    const terminalTag = process.env.CODE_ENV_TERMINAL_TAG || null;
+    const cwd = process.cwd();
+    const startMs = Date.now();
+    const minBindingTimestampMs = startMs - SESSION_BINDING_START_GRACE_MS;
+    const sessionRoot = type === "codex" ? (0, usage_1.getCodexSessionsPath)(config) : (0, usage_1.getClaudeSessionsPath)(config);
+    const initialBindingIndex = (0, usage_1.readSessionBindingIndex)(config, configPath);
+    const initialUnboundFiles = new Set();
+    for (const filePath of collectSessionFiles(sessionRoot)) {
+        if (!initialBindingIndex.byFile.has(filePath)) {
+            initialUnboundFiles.add(filePath);
+        }
+    }
+    const statuslineEnabled = isStatuslineEnabled(type);
+    if (type === "claude") {
+        await ensureClaudeStatuslineConfig(config, statuslineEnabled);
+    }
+    else if (type === "codex") {
+        await (0, codex_1.ensureCodexStatuslineConfig)(config, statuslineEnabled);
+    }
+    if (profileKey) {
+        (0, usage_1.logProfileUse)(config, configPath, profileKey, type, terminalTag, cwd);
+    }
+    const child = (0, child_process_1.spawn)(target, args, { stdio: "inherit", env: process.env });
+    const canBindSession = Boolean(profileKey || profileName);
+    let boundSession = null;
+    let bindingTimer = null;
+    const tryBindSession = () => {
+        if (!canBindSession || boundSession)
+            return;
+        const bindingIndex = (0, usage_1.readSessionBindingIndex)(config, configPath);
+        const candidate = findLatestUnboundSessionMeta(sessionRoot, type, bindingIndex, minBindingTimestampMs, cwd, initialUnboundFiles);
+        if (!candidate)
+            return;
+        boundSession = candidate;
+        (0, usage_1.logSessionBinding)(config, configPath, type, profileKey, profileName, terminalTag, cwd, boundSession.filePath, boundSession.sessionId, boundSession.timestamp);
+        if (bindingTimer) {
+            clearInterval(bindingTimer);
+            bindingTimer = null;
+        }
+    };
+    if (canBindSession) {
+        tryBindSession();
+        bindingTimer = setInterval(tryBindSession, SESSION_BINDING_POLL_MS);
+    }
+    const forwardSignal = (signal) => {
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // ignore
+        }
+    };
+    process.on("SIGINT", forwardSignal);
+    process.on("SIGTERM", forwardSignal);
+    const exitCode = await new Promise((resolve) => {
+        child.on("error", (err) => {
+            process.off("SIGINT", forwardSignal);
+            process.off("SIGTERM", forwardSignal);
+            if (bindingTimer) {
+                clearInterval(bindingTimer);
+                bindingTimer = null;
+            }
+            console.error(`codenv: failed to launch ${target}: ${err.message}`);
+            resolve(1);
+        });
+        child.on("exit", (code, signal) => {
+            process.off("SIGINT", forwardSignal);
+            process.off("SIGTERM", forwardSignal);
+            if (bindingTimer) {
+                clearInterval(bindingTimer);
+                bindingTimer = null;
+            }
+            const bindingIndex = (0, usage_1.readSessionBindingIndex)(config, configPath);
+            const sessionMeta = findLatestUnboundSessionMeta(sessionRoot, type, bindingIndex, minBindingTimestampMs, cwd, initialUnboundFiles);
+            if (!boundSession && sessionMeta && (profileKey || profileName)) {
+                (0, usage_1.logSessionBinding)(config, configPath, type, profileKey, profileName, terminalTag, cwd, sessionMeta.filePath, sessionMeta.sessionId, sessionMeta.timestamp);
+            }
+            if (typeof code === "number") {
+                resolve(code);
+                return;
+            }
+            if (signal) {
+                resolve(1);
+                return;
+            }
+            resolve(0);
+        });
+    });
+    return exitCode;
+}

package/bin/commands/list.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printList = printList;
+const display_1 = require("../profile/display");
+const defaults_1 = require("../config/defaults");
+const usage_1 = require("../usage");
+function printList(config, configPath) {
+    const rows = (0, display_1.buildListRows)(config, defaults_1.getResolvedDefaultProfileKeys);
+    if (rows.length === 0) {
+        console.log("(no profiles found)");
+        return;
+    }
+    try {
+        const usageTotals = (0, usage_1.readUsageTotalsIndex)(config, configPath, true);
+        if (usageTotals) {
+            for (const row of rows) {
+                if (!row.usageType)
+                    continue;
+                const usage = (0, usage_1.resolveUsageTotalsForProfile)(usageTotals, row.usageType, row.key, row.name);
+                if (!usage)
+                    continue;
+                row.todayTokens = usage.today;
+                row.totalTokens = usage.total;
+            }
+        }
+    }
+    catch {
+        // ignore usage sync errors
+    }
+    const headerName = "PROFILE";
+    const headerType = "TYPE";
+    const headerToday = "TODAY";
+    const headerTotal = "TOTAL";
+    const headerNote = "NOTE";
+    const todayTexts = rows.map((row) => (0, usage_1.formatTokenCount)(row.todayTokens));
+    const totalTexts = rows.map((row) => (0, usage_1.formatTokenCount)(row.totalTokens));
+    const nameWidth = Math.max(headerName.length, ...rows.map((row) => row.name.length));
+    const typeWidth = Math.max(headerType.length, ...rows.map((row) => row.type.length));
+    const todayWidth = Math.max(headerToday.length, ...todayTexts.map((v) => v.length));
+    const totalWidth = Math.max(headerTotal.length, ...totalTexts.map((v) => v.length));
+    const noteWidth = Math.max(headerNote.length, ...rows.map((row) => row.note.length));
+    const formatRow = (name, type, today, total, note) => `${name.padEnd(nameWidth)}  ${type.padEnd(typeWidth)}  ${today.padStart(todayWidth)}  ${total.padStart(totalWidth)}  ${note.padEnd(noteWidth)}`;
+    console.log(formatRow(headerName, headerType, headerToday, headerTotal, headerNote));
+    console.log(formatRow("-".repeat(nameWidth), "-".repeat(typeWidth), "-".repeat(todayWidth), "-".repeat(totalWidth), "-".repeat(noteWidth)));
+    for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const todayText = todayTexts[i] || "-";
+        const totalText = totalTexts[i] || "-";
+        const line = formatRow(row.name, row.type, todayText, totalText, row.note);
+        if (row.active) {
+            console.log(`\x1b[32m${line}\x1b[0m`);
+        }
+        else {
+            console.log(line);
+        }
+    }
+}

package/bin/commands/show.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printShow = printShow;
+function printShow(config, profileName) {
+    const profile = config.profiles && config.profiles[profileName];
+    if (!profile) {
+        throw new Error(`Unknown profile: ${profileName}`);
+    }
+    console.log(JSON.stringify(profile, null, 2));
+}

package/bin/commands/statusline.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printStatusline = printStatusline;
+const statusline_1 = require("../statusline");
+function printStatusline(config, configPath, args) {
+    const result = (0, statusline_1.buildStatuslineResult)(args, config, configPath);
+    if (args.format === "json") {
+        console.log(JSON.stringify(result.json));
+        return;
+    }
+    console.log(result.text);
+}

package/bin/commands/unset.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printUnset = printUnset;
+const constants_1 = require("../constants");
+const defaults_1 = require("../config/defaults");
+function printUnset(config) {
+    const keySet = new Set();
+    if (Array.isArray(config.unset)) {
+        for (const key of config.unset)
+            keySet.add(key);
+    }
+    for (const type of constants_1.DEFAULT_PROFILE_TYPES) {
+        for (const key of (0, defaults_1.getTypeDefaultUnsetKeys)(type))
+            keySet.add(key);
+    }
+    if (keySet.size === 0)
+        return;
+    const lines = Array.from(keySet, (key) => `unset ${key}`);
+    console.log(lines.join("\n"));
+}

package/bin/commands/use.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUseLines = buildUseLines;
+exports.printUse = printUse;
+/**
+ * Use command - apply profile environment
+ */
+const path = require("path");
+const constants_1 = require("../constants");
+const utils_1 = require("../shell/utils");
+const type_1 = require("../profile/type");
+const match_1 = require("../profile/match");
+const display_1 = require("../profile/display");
+const defaults_1 = require("../config/defaults");
+function buildUseLines(config, profileName, requestedType, includeGlobalUnset, configPath = null) {
+    const profile = config.profiles && config.profiles[profileName];
+    if (!profile) {
+        throw new Error(`Unknown profile: ${profileName}`);
+    }
+    const unsetLines = [];
+    const exportLines = [];
+    const postLines = [];
+    const unsetKeys = new Set();
+    const activeType = (0, type_1.inferProfileType)(profileName, profile, requestedType);
+    const effectiveEnv = (0, display_1.buildEffectiveEnv)(profile, activeType);
+    const addUnset = (key) => {
+        if (unsetKeys.has(key))
+            return;
+        if (Object.prototype.hasOwnProperty.call(effectiveEnv, key))
+            return;
+        unsetKeys.add(key);
+        unsetLines.push(`unset ${key}`);
+    };
+    if (includeGlobalUnset) {
+        for (const key of (0, defaults_1.getFilteredUnsetKeys)(config, activeType)) {
+            addUnset(key);
+        }
+    }
+    if (activeType) {
+        for (const key of (0, defaults_1.getTypeDefaultUnsetKeys)(activeType)) {
+            addUnset(key);
+        }
+    }
+    for (const key of Object.keys(effectiveEnv)) {
+        const value = effectiveEnv[key];
+        if (value === null || value === undefined || value === "") {
+            if (!unsetKeys.has(key)) {
+                unsetKeys.add(key);
+                unsetLines.push(`unset ${key}`);
+            }
+        }
+        else {
+            exportLines.push(`export ${key}=${(0, utils_1.shellEscape)(value)}`);
+        }
+    }
+    if (activeType) {
+        const typeSuffix = activeType.toUpperCase();
+        const displayName = (0, type_1.getProfileDisplayName)(profileName, profile, activeType);
+        exportLines.push(`export CODE_ENV_PROFILE_KEY_${typeSuffix}=${(0, utils_1.shellEscape)(profileName)}`);
+        exportLines.push(`export CODE_ENV_PROFILE_NAME_${typeSuffix}=${(0, utils_1.shellEscape)(displayName)}`);
+    }
+    if (configPath) {
+        exportLines.push(`export CODE_ENV_CONFIG_PATH=${(0, utils_1.shellEscape)(configPath)}`);
+    }
+    if ((0, match_1.shouldRemoveCodexAuth)(profileName, profile, requestedType)) {
+        const codexApiKey = effectiveEnv.OPENAI_API_KEY;
+        const authDir = path.dirname(constants_1.CODEX_AUTH_PATH);
+        const authJson = codexApiKey === null || codexApiKey === undefined || codexApiKey === ""
+            ? "null"
+            : JSON.stringify({ OPENAI_API_KEY: String(codexApiKey) });
+        postLines.push(`mkdir -p ${(0, utils_1.shellEscape)(authDir)}`);
+        postLines.push(`printf '%s\\n' ${(0, utils_1.shellEscape)(authJson)} > ${(0, utils_1.shellEscape)(constants_1.CODEX_AUTH_PATH)}`);
+    }
+    if (Array.isArray(profile.removeFiles)) {
+        for (const p of profile.removeFiles) {
+            const expanded = (0, utils_1.expandEnv)(p);
+            if (expanded)
+                postLines.push(`rm -f ${(0, utils_1.shellEscape)(expanded)}`);
+        }
+    }
+    if (Array.isArray(profile.commands)) {
+        for (const cmd of profile.commands) {
+            if (cmd && String(cmd).trim())
+                postLines.push(String(cmd));
+        }
+    }
+    return [...unsetLines, ...exportLines, ...postLines];
+}
+function printUse(config, profileName, requestedType = null, includeGlobalUnset = true, configPath = null) {
+    const lines = buildUseLines(config, profileName, requestedType, includeGlobalUnset, configPath);
+    console.log(lines.join("\n"));
+}

package/bin/config/defaults.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultProfiles = getDefaultProfiles;
+exports.deleteDefaultProfileEntry = deleteDefaultProfileEntry;
+exports.resolveDefaultProfileForType = resolveDefaultProfileForType;
+exports.getResolvedDefaultProfileKeys = getResolvedDefaultProfileKeys;
+exports.getTypeDefaultUnsetKeys = getTypeDefaultUnsetKeys;
+exports.getFilteredUnsetKeys = getFilteredUnsetKeys;
+const constants_1 = require("../constants");
+const type_1 = require("../profile/type");
+const resolve_1 = require("../profile/resolve");
+function getDefaultProfiles(config) {
+    const defaults = {};
+    if (!config || typeof config !== "object")
+        return defaults;
+    if (!config.defaultProfiles || typeof config.defaultProfiles !== "object") {
+        return defaults;
+    }
+    for (const [rawType, rawValue] of Object.entries(config.defaultProfiles)) {
+        const type = (0, type_1.normalizeType)(rawType);
+        if (!type)
+            continue;
+        const trimmed = String(rawValue !== null && rawValue !== void 0 ? rawValue : "").trim();
+        if (trimmed)
+            defaults[type] = trimmed;
+    }
+    return defaults;
+}
+function deleteDefaultProfileEntry(config, type) {
+    if (!config.defaultProfiles || typeof config.defaultProfiles !== "object") {
+        return false;
+    }
+    let changed = false;
+    for (const key of Object.keys(config.defaultProfiles)) {
+        if ((0, type_1.normalizeType)(key) === type) {
+            delete config.defaultProfiles[key];
+            changed = true;
+        }
+    }
+    return changed;
+}
+function resolveDefaultProfileForType(config, type, value) {
+    const trimmed = String(value !== null && value !== void 0 ? value : "").trim();
+    if (!trimmed)
+        return null;
+    const params = trimmed.split(/\s+/).filter(Boolean);
+    if (params.length === 0)
+        return null;
+    const explicitType = (0, type_1.normalizeType)(params[0]);
+    if (explicitType) {
+        if (explicitType !== type) {
+            throw new Error(`Default profile for "${type}" must match type "${type}".`);
+        }
+        return (0, resolve_1.resolveProfileName)(config, params);
+    }
+    return (0, resolve_1.resolveProfileName)(config, [type, ...params]);
+}
+function getResolvedDefaultProfileKeys(config) {
+    const defaults = getDefaultProfiles(config);
+    const resolved = {};
+    for (const type of constants_1.DEFAULT_PROFILE_TYPES) {
+        const value = defaults[type];
+        if (!value)
+            continue;
+        try {
+            const profileName = resolveDefaultProfileForType(config, type, value);
+            if (profileName)
+                resolved[type] = profileName;
+        }
+        catch (err) {
+            // ignore invalid defaults for list output
+        }
+    }
+    return resolved;
+}
+function getTypeDefaultUnsetKeys(type) {
+    return constants_1.DEFAULT_UNSET_KEYS[type] || [];
+}
+function getFilteredUnsetKeys(config, activeType) {
+    const keys = Array.isArray(config.unset) ? config.unset : [];
+    if (!activeType)
+        return [...keys];
+    const otherDefaults = new Set(constants_1.DEFAULT_PROFILE_TYPES.filter((type) => type !== activeType).flatMap((type) => constants_1.DEFAULT_UNSET_KEYS[type]));
+    return keys.filter((key) => !otherDefaults.has(key));
+}

package/bin/config/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilteredUnsetKeys = exports.getTypeDefaultUnsetKeys = exports.getResolvedDefaultProfileKeys = exports.resolveDefaultProfileForType = exports.deleteDefaultProfileEntry = exports.getDefaultProfiles = exports.writeConfig = exports.readConfigIfExists = exports.readConfig = exports.findConfigPathForWrite = exports.findConfigPath = exports.getDefaultConfigPath = void 0;
+/**
+ * Config module exports
+ */
+var io_1 = require("./io");
+Object.defineProperty(exports, "getDefaultConfigPath", { enumerable: true, get: function () { return io_1.getDefaultConfigPath; } });
+Object.defineProperty(exports, "findConfigPath", { enumerable: true, get: function () { return io_1.findConfigPath; } });
+Object.defineProperty(exports, "findConfigPathForWrite", { enumerable: true, get: function () { return io_1.findConfigPathForWrite; } });
+Object.defineProperty(exports, "readConfig", { enumerable: true, get: function () { return io_1.readConfig; } });
+Object.defineProperty(exports, "readConfigIfExists", { enumerable: true, get: function () { return io_1.readConfigIfExists; } });
+Object.defineProperty(exports, "writeConfig", { enumerable: true, get: function () { return io_1.writeConfig; } });
+var defaults_1 = require("./defaults");
+Object.defineProperty(exports, "getDefaultProfiles", { enumerable: true, get: function () { return defaults_1.getDefaultProfiles; } });
+Object.defineProperty(exports, "deleteDefaultProfileEntry", { enumerable: true, get: function () { return defaults_1.deleteDefaultProfileEntry; } });
+Object.defineProperty(exports, "resolveDefaultProfileForType", { enumerable: true, get: function () { return defaults_1.resolveDefaultProfileForType; } });
+Object.defineProperty(exports, "getResolvedDefaultProfileKeys", { enumerable: true, get: function () { return defaults_1.getResolvedDefaultProfileKeys; } });
+Object.defineProperty(exports, "getTypeDefaultUnsetKeys", { enumerable: true, get: function () { return defaults_1.getTypeDefaultUnsetKeys; } });
+Object.defineProperty(exports, "getFilteredUnsetKeys", { enumerable: true, get: function () { return defaults_1.getFilteredUnsetKeys; } });