akm-cli 0.0.0 → 0.0.17

package/dist/config.js

@@ -0,0 +1,338 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getConfigDir as _getConfigDir, getConfigPath as _getConfigPath } from "./paths";
+// ── Defaults ────────────────────────────────────────────────────────────────
+export const DEFAULT_CONFIG = {
+    semanticSearch: true,
+    searchPaths: [],
+    registries: [{ url: "https://raw.githubusercontent.com/itlackey/akm-registry/main/index.json", name: "official" }],
+    output: {
+        format: "json",
+        detail: "brief",
+    },
+};
+// ── Paths ───────────────────────────────────────────────────────────────────
+export function getConfigDir(env, platform) {
+    return _getConfigDir(env, platform);
+}
+export function getConfigPath() {
+    return _getConfigPath();
+}
+// ── Load / Save / Update ────────────────────────────────────────────────────
+let cachedConfig;
+export function loadConfig() {
+    const configPath = getConfigPath();
+    try {
+        const stat = fs.statSync(configPath);
+        if (cachedConfig && cachedConfig.path === configPath && cachedConfig.mtime === stat.mtimeMs) {
+            return cachedConfig.config;
+        }
+    }
+    catch {
+        // File doesn't exist — return defaults below
+        cachedConfig = undefined;
+        return { ...DEFAULT_CONFIG };
+    }
+    const raw = readConfigObject(configPath);
+    const config = raw ? pickKnownKeys(raw) : { ...DEFAULT_CONFIG };
+    // Inject API keys from environment variables.
+    // API keys should be provided via AKM_EMBED_API_KEY and AKM_LLM_API_KEY
+    // rather than stored in the config file.
+    if (config.embedding && !config.embedding.apiKey) {
+        const envKey = process.env.AKM_EMBED_API_KEY?.trim();
+        if (envKey)
+            config.embedding.apiKey = envKey;
+    }
+    if (config.llm && !config.llm.apiKey) {
+        const envKey = process.env.AKM_LLM_API_KEY?.trim();
+        if (envKey)
+            config.llm.apiKey = envKey;
+    }
+    // Cache the parsed config with its path and mtime for subsequent calls
+    try {
+        const stat = fs.statSync(configPath);
+        cachedConfig = { config, path: configPath, mtime: stat.mtimeMs };
+    }
+    catch {
+        // If we can't stat (unlikely since we just read it), skip caching
+    }
+    return config;
+}
+export function saveConfig(config) {
+    cachedConfig = undefined;
+    const configPath = getConfigPath();
+    const dir = path.dirname(configPath);
+    fs.mkdirSync(dir, { recursive: true });
+    const sanitized = sanitizeConfigForWrite(config);
+    const tmpPath = `${configPath}.tmp.${process.pid}`;
+    try {
+        fs.writeFileSync(tmpPath, `${JSON.stringify(sanitized, null, 2)}\n`, "utf8");
+        fs.renameSync(tmpPath, configPath);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch {
+            /* ignore cleanup failure */
+        }
+        throw err;
+    }
+}
+/**
+ * Strip apiKey fields before writing config to disk.
+ * API keys should be provided via environment variables
+ * AKM_EMBED_API_KEY and AKM_LLM_API_KEY.
+ */
+function sanitizeConfigForWrite(config) {
+    const sanitized = { ...config };
+    if (sanitized.embedding) {
+        const { apiKey, ...rest } = sanitized.embedding;
+        sanitized.embedding = rest;
+    }
+    if (sanitized.llm) {
+        const { apiKey, ...rest } = sanitized.llm;
+        sanitized.llm = rest;
+    }
+    return sanitized;
+}
+export function updateConfig(partial) {
+    const current = loadConfig();
+    const merged = { ...current, ...partial };
+    saveConfig(merged);
+    return merged;
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function pickKnownKeys(raw) {
+    const config = { ...DEFAULT_CONFIG };
+    if (typeof raw.stashDir === "string" && raw.stashDir.trim()) {
+        config.stashDir = raw.stashDir.trim();
+    }
+    if (typeof raw.semanticSearch === "boolean") {
+        config.semanticSearch = raw.semanticSearch;
+    }
+    if (Array.isArray(raw.searchPaths)) {
+        config.searchPaths = raw.searchPaths.filter((d) => typeof d === "string");
+    }
+    const embedding = parseEmbeddingConfig(raw.embedding);
+    if (embedding)
+        config.embedding = embedding;
+    const llm = parseLlmConfig(raw.llm);
+    if (llm)
+        config.llm = llm;
+    const installed = parseInstalledEntries(raw.installed);
+    if (installed)
+        config.installed = installed;
+    const registries = parseRegistriesConfig(raw.registries);
+    if (registries)
+        config.registries = registries;
+    const output = parseOutputConfig(raw.output);
+    if (output)
+        config.output = output;
+    return config;
+}
+function parseOutputConfig(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const obj = value;
+    const output = {};
+    if (obj.format === "json" || obj.format === "yaml" || obj.format === "text") {
+        output.format = obj.format;
+    }
+    if (obj.detail === "brief" || obj.detail === "normal" || obj.detail === "full") {
+        output.detail = obj.detail;
+    }
+    return Object.keys(output).length > 0 ? output : undefined;
+}
+function readConfigObject(configPath) {
+    try {
+        const text = fs.readFileSync(configPath, "utf8");
+        const raw = JSON.parse(stripJsonComments(text));
+        if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+            return undefined;
+        return raw;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Strip JavaScript-style comments from a JSON string (JSONC support).
+ * Handles // line comments and /* block comments while preserving
+ * comment-like sequences inside quoted strings.
+ */
+export function stripJsonComments(text) {
+    let result = "";
+    let i = 0;
+    let inString = false;
+    let stringChar = "";
+    while (i < text.length) {
+        if (inString) {
+            if (text[i] === "\\") {
+                result += text[i] + (text[i + 1] ?? "");
+                i += 2;
+                continue;
+            }
+            if (text[i] === stringChar) {
+                inString = false;
+            }
+            result += text[i];
+            i++;
+            continue;
+        }
+        if (text[i] === '"' || text[i] === "'") {
+            inString = true;
+            stringChar = text[i];
+            result += text[i];
+            i++;
+            continue;
+        }
+        if (text[i] === "/" && text[i + 1] === "/") {
+            while (i < text.length && text[i] !== "\n")
+                i++;
+            continue;
+        }
+        if (text[i] === "/" && text[i + 1] === "*") {
+            i += 2;
+            while (i < text.length && !(text[i] === "*" && text[i + 1] === "/"))
+                i++;
+            i += 2;
+            continue;
+        }
+        result += text[i];
+        i++;
+    }
+    return result;
+}
+function parseEmbeddingConfig(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const obj = value;
+    if (typeof obj.endpoint !== "string" || !obj.endpoint)
+        return undefined;
+    if (typeof obj.model !== "string" || !obj.model)
+        return undefined;
+    const result = {
+        endpoint: obj.endpoint,
+        model: obj.model,
+    };
+    if (typeof obj.provider === "string" && obj.provider) {
+        result.provider = obj.provider;
+    }
+    if ("dimension" in obj) {
+        if (typeof obj.dimension !== "number" ||
+            !Number.isFinite(obj.dimension) ||
+            !Number.isInteger(obj.dimension) ||
+            obj.dimension <= 0) {
+            return undefined;
+        }
+        result.dimension = obj.dimension;
+    }
+    if (typeof obj.apiKey === "string" && obj.apiKey) {
+        result.apiKey = obj.apiKey;
+    }
+    return result;
+}
+function parseLlmConfig(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const obj = value;
+    if (typeof obj.endpoint !== "string" || !obj.endpoint)
+        return undefined;
+    if (typeof obj.model !== "string" || !obj.model)
+        return undefined;
+    const result = {
+        endpoint: obj.endpoint,
+        model: obj.model,
+    };
+    if (typeof obj.provider === "string" && obj.provider) {
+        result.provider = obj.provider;
+    }
+    if (typeof obj.temperature === "number" && Number.isFinite(obj.temperature)) {
+        result.temperature = obj.temperature;
+    }
+    if ("maxTokens" in obj) {
+        if (typeof obj.maxTokens !== "number" ||
+            !Number.isFinite(obj.maxTokens) ||
+            !Number.isInteger(obj.maxTokens) ||
+            obj.maxTokens <= 0) {
+            return undefined;
+        }
+        result.maxTokens = obj.maxTokens;
+    }
+    if (typeof obj.apiKey === "string" && obj.apiKey) {
+        result.apiKey = obj.apiKey;
+    }
+    return result;
+}
+function parseInstalledEntries(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const entries = value
+        .map((entry) => parseInstalledKitEntry(entry))
+        .filter((entry) => entry !== undefined);
+    return entries.length > 0 ? entries : undefined;
+}
+function parseInstalledKitEntry(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const obj = value;
+    const id = asNonEmptyString(obj.id);
+    const source = asKitSource(obj.source);
+    const ref = asNonEmptyString(obj.ref);
+    const artifactUrl = asNonEmptyString(obj.artifactUrl);
+    const stashRoot = asNonEmptyString(obj.stashRoot);
+    const cacheDir = asNonEmptyString(obj.cacheDir);
+    const installedAt = asNonEmptyString(obj.installedAt);
+    if (!id || !source || !ref || !artifactUrl || !stashRoot || !cacheDir || !installedAt)
+        return undefined;
+    const entry = {
+        id,
+        source,
+        ref,
+        artifactUrl,
+        stashRoot,
+        cacheDir,
+        installedAt,
+    };
+    const resolvedVersion = asNonEmptyString(obj.resolvedVersion);
+    if (resolvedVersion)
+        entry.resolvedVersion = resolvedVersion;
+    const resolvedRevision = asNonEmptyString(obj.resolvedRevision);
+    if (resolvedRevision)
+        entry.resolvedRevision = resolvedRevision;
+    return entry;
+}
+function asNonEmptyString(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function asKitSource(value) {
+    if (value === "npm" || value === "github" || value === "git" || value === "local")
+        return value;
+    return undefined;
+}
+function parseRegistriesConfig(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const entries = value
+        .map((entry) => parseRegistryConfigEntry(entry))
+        .filter((entry) => entry !== undefined);
+    // Return the array even if empty — an explicit empty array means "no registries"
+    // which overrides the default. Only return undefined if the field was not an array.
+    return entries;
+}
+function parseRegistryConfigEntry(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const obj = value;
+    const url = asNonEmptyString(obj.url);
+    if (!url || !url.startsWith("http"))
+        return undefined;
+    const entry = { url };
+    const name = asNonEmptyString(obj.name);
+    if (name)
+        entry.name = name;
+    if (typeof obj.enabled === "boolean")
+        entry.enabled = obj.enabled;
+    return entry;
+}