@aria-cli/cli 1.0.51 → 1.0.54

package/dist/headless/hook-service.js

@@ -1,42 +0,0 @@
-import path from "node:path";
-import { actionConsolidate, actionExtract, actionHarvest, actionIngest, actionReflect, } from "./hook-actions.js";
-function defaultMemoryPath(arionName) {
-    return path.join("arions", arionName, "memory.db");
-}
-function toHookOutput(result) {
-    if (result.output && typeof result.output === "object") {
-        return result.output;
-    }
-    return { value: result.output };
-}
-export function createHookService(options) {
-    const resolveMemoryPath = () => process.env.ARIA_MEMORY_PATH ||
-        defaultMemoryPath(options.getArionName?.() ?? options.arionName);
-    const withMemoria = async (action) => {
-        const memoria = await options.cli.pool.get(options.resolveMemoriaPath ? await options.resolveMemoriaPath() : resolveMemoryPath());
-        return action(memoria);
-    };
-    return {
-        async extract(input, hookOptions) {
-            return withMemoria(async (memoria) => toHookOutput(await actionExtract(memoria, JSON.stringify(input.pairs ?? []), {
-                signal: hookOptions?.signal,
-            })));
-        },
-        async reflect(input, hookOptions) {
-            const payload = typeof input.conversation === "string"
-                ? input.conversation
-                : JSON.stringify(input.messages ?? []);
-            return withMemoria(async (memoria) => toHookOutput(await actionReflect(memoria, options.cli.router, payload, hookOptions)));
-        },
-        async consolidate(_input, hookOptions) {
-            return withMemoria(async (memoria) => toHookOutput(await actionConsolidate(memoria, hookOptions)));
-        },
-        async ingest(_input, hookOptions) {
-            return withMemoria(async (memoria) => toHookOutput(await actionIngest(memoria, hookOptions)));
-        },
-        async harvest(input, hookOptions) {
-            return withMemoria(async (memoria) => toHookOutput(await actionHarvest(memoria, options.cli.router, input, hookOptions)));
-        },
-    };
-}
-//# sourceMappingURL=hook-service.js.map

package/dist/headless/kernel-services.js

@@ -1,216 +0,0 @@
-import { ArionManager, ArionStorage, DEFAULT_SAFETY_CONFIG } from "@aria-cli/aria";
-import { getDefaultModelByTier, resolveModelReference } from "@aria-cli/models";
-import { getProviderOptions, handleLoginCommand } from "../commands/login-handler.js";
-import { handleLogoutCommand } from "../commands/logout-handler.js";
-import { loadConfig, saveConfig } from "../config.js";
-import { getAvailableThemes, getTheme, setTheme } from "../ui/theme/index.js";
-import { resolveCanonicalArionName } from "./bootstrap-fast-path.js";
-async function createArionManager(cli) {
-    const storage = new ArionStorage(cli.ariaDir);
-    const manager = new ArionManager(storage, cli.memoriaFactory);
-    manager.setRouter(cli.router);
-    await manager.initialize();
-    return manager;
-}
-function selectModel(availableModels, requested) {
-    return resolveModelReference(requested, availableModels);
-}
-function defaultModel(tier) {
-    return getDefaultModelByTier((tier ?? "balanced"));
-}
-export function createHeadlessCapabilityServices(options) {
-    const cli = options.cli;
-    let activeArionName = resolveCanonicalArionName(cli.ariaDir, options.activeArionName ?? cli.config.activeArion ?? "ARIA");
-    let currentModelName;
-    let availableModels = [...cli.availableModels];
-    let managerPromise = null;
-    const memoriaByArion = new Map();
-    const getManager = async () => {
-        managerPromise ??= createArionManager(cli);
-        return managerPromise;
-    };
-    const resolveActiveArion = async () => {
-        const manager = await getManager();
-        const selected = await manager.get(activeArionName);
-        if (!selected) {
-            throw new Error(`Unable to resolve active Arion ${activeArionName}`);
-        }
-        return selected;
-    };
-    const resolveActiveMemoria = async () => {
-        const arion = await resolveActiveArion();
-        const cached = memoriaByArion.get(arion.name);
-        if (cached) {
-            return cached;
-        }
-        const manager = await getManager();
-        const memoria = await manager.getMemoria(arion);
-        if (!memoria) {
-            throw new Error(`Memoria is unavailable for Arion ${arion.name}`);
-        }
-        memoriaByArion.set(arion.name, memoria);
-        return memoria;
-    };
-    const arionManager = {
-        list: async () => (await getManager()).list(),
-        hatch: async (input) => (await getManager()).hatch(input),
-        get: async (name) => (await getManager()).get(name),
-        wake: async (name) => {
-            await (await getManager()).wake(name);
-        },
-        rest: async (name, serviceOptions) => {
-            await (await getManager()).rest(name, serviceOptions);
-        },
-    };
-    const config = {
-        async getTheme() {
-            return loadConfig().theme ?? getTheme().name;
-        },
-        async setTheme(theme) {
-            const normalized = theme.trim();
-            if (!getAvailableThemes().includes(normalized)) {
-                throw new Error(`Unknown theme: ${theme}`);
-            }
-            const current = loadConfig();
-            current.theme = normalized;
-            saveConfig(current);
-            setTheme(normalized);
-            return { theme: normalized };
-        },
-        async getAutonomy() {
-            return loadConfig().autonomy ?? DEFAULT_SAFETY_CONFIG.autonomy;
-        },
-        async setAutonomy(autonomy) {
-            if (!["minimal", "balanced", "high", "full"].includes(autonomy)) {
-                throw new Error(`Invalid autonomy level: ${autonomy}`);
-            }
-            const current = loadConfig();
-            current.autonomy = autonomy;
-            saveConfig(current);
-            return { autonomy };
-        },
-        async getActiveArion() {
-            return activeArionName;
-        },
-        async setActiveArion(name) {
-            const requestedArionName = name.trim() || "ARIA";
-            let nextArionName = resolveCanonicalArionName(cli.ariaDir, requestedArionName);
-            try {
-                const manager = await getManager();
-                const resolved = await manager.get(requestedArionName);
-                if (resolved?.name) {
-                    nextArionName = resolved.name;
-                }
-            }
-            catch {
-                // Persist the best available canonical spelling even if runtime resolution fails.
-            }
-            const current = loadConfig();
-            current.activeArion = nextArionName;
-            saveConfig(current);
-            activeArionName = nextArionName;
-        },
-    };
-    const modelDiscovery = {
-        async listAvailable() {
-            return availableModels;
-        },
-        async refresh(force) {
-            availableModels = [...(await cli.refreshAvailableModels(force))];
-            return availableModels;
-        },
-        async getCurrentModel() {
-            if (currentModelName) {
-                return currentModelName;
-            }
-            const current = loadConfig();
-            try {
-                const arion = await resolveActiveArion();
-                if (typeof arion.preferredModel === "string" && arion.preferredModel.trim().length > 0) {
-                    currentModelName =
-                        resolveModelReference(arion.preferredModel)?.shortName ?? arion.preferredModel.trim();
-                    return currentModelName;
-                }
-            }
-            catch {
-                // Fall back to the tier default when the active Arion is unavailable.
-            }
-            currentModelName = defaultModel(current.preferredTier ?? cli.config.preferredTier)?.shortName;
-            return currentModelName;
-        },
-        async setCurrentModel(model) {
-            const selected = selectModel(availableModels, model) ??
-                selectModel(await cli.refreshAvailableModels(true), model);
-            if (!selected) {
-                throw new Error(`Unknown model: ${model}`);
-            }
-            currentModelName = selected.shortName;
-            const current = loadConfig();
-            current.preferredTier = selected.tier;
-            saveConfig(current);
-            availableModels = [...(await cli.refreshAvailableModels(false))];
-            try {
-                const manager = await getManager();
-                const arion = await resolveActiveArion();
-                await manager.setPreferredModel(arion.name, selected.shortName);
-            }
-            catch {
-                // Persisted config is authoritative; per-Arion model affinity is best-effort.
-            }
-            return {
-                currentModel: selected.shortName,
-                tier: selected.tier,
-            };
-        },
-        async getSessionModel() {
-            return currentModelName;
-        },
-    };
-    void (async () => {
-        try {
-            const arion = await resolveActiveArion();
-            if (typeof arion.preferredModel === "string" && arion.preferredModel.trim().length > 0) {
-                currentModelName =
-                    resolveModelReference(arion.preferredModel)?.shortName ?? arion.preferredModel.trim();
-                return;
-            }
-        }
-        catch {
-            // Ignore startup warmup failures; lazy getters handle fallback.
-        }
-        currentModelName = defaultModel(loadConfig().preferredTier ?? cli.config.preferredTier)?.shortName;
-    })();
-    const auth = {
-        async status() {
-            return { providers: getProviderOptions() };
-        },
-        async login(input) {
-            const args = typeof input.args === "string" ? input.args : "";
-            return handleLoginCommand(args);
-        },
-        async logout(input) {
-            const args = typeof input.args === "string" ? input.args : "";
-            return handleLogoutCommand(args);
-        },
-    };
-    const memoria = new Proxy({}, {
-        get(_target, prop) {
-            return async (...args) => {
-                const currentMemoria = await resolveActiveMemoria();
-                const method = currentMemoria[prop];
-                if (typeof method !== "function") {
-                    throw new Error(`Memoria method ${String(prop)} is unavailable`);
-                }
-                return method.apply(currentMemoria, args);
-            };
-        },
-    });
-    return {
-        arionManager: options.overrides?.arionManager ?? arionManager,
-        auth: options.overrides?.auth ?? auth,
-        config: options.overrides?.config ?? config,
-        memoria: options.overrides?.memoria ?? memoria,
-        modelDiscovery: options.overrides?.modelDiscovery ?? modelDiscovery,
-    };
-}
-//# sourceMappingURL=kernel-services.js.map