@aria-cli/cli 1.0.51 → 1.0.54

package/dist/headless/operations/arion.js

@@ -1,119 +0,0 @@
-import { failureResult, successResult, unsupportedWhenMissing } from "./utils.js";
-function defaultHatchConfig(input) {
-    return {
-        name: input.name ?? "ARIA",
-        ...(input.emoji ? { emoji: input.emoji } : {}),
-        personality: {
-            traits: ["helpful", "curious"],
-            style: "friendly",
-        },
-        ...(input.description
-            ? {
-                profile: {
-                    background: input.description,
-                },
-            }
-            : {}),
-        createdBy: "headless",
-    };
-}
-function buildGuidedHatchPrompt(name, description) {
-    const trimmedDescription = description?.trim();
-    return trimmedDescription
-        ? `I want to create a new arion named "${name}". ${trimmedDescription}`
-        : `I want to create a new arion named "${name}". Help me design their personality.`;
-}
-export function createArionOperationHandlers(ctx) {
-    const arionManager = ctx.arionManager;
-    if (!arionManager?.list ||
-        !arionManager.hatch ||
-        !arionManager.get ||
-        !arionManager.wake ||
-        !arionManager.rest) {
-        return {
-            "arion.list": unsupportedWhenMissing("arionManager", "arion.list"),
-            "arion.hatch": unsupportedWhenMissing("arionManager", "arion.hatch"),
-            "arion.become": unsupportedWhenMissing("arionManager", "arion.become"),
-            "arion.rest": unsupportedWhenMissing("arionManager", "arion.rest"),
-            "arion.wake": unsupportedWhenMissing("arionManager", "arion.wake"),
-            "arion.create": unsupportedWhenMissing("arionManager", "arion.create"),
-        };
-    }
-    return {
-        "arion.list": async function* (requestId) {
-            const list = arionManager.list;
-            yield successResult(requestId, "arion.list", {
-                arions: await list(),
-            });
-        },
-        "arion.hatch": async function* (requestId, input) {
-            const get = arionManager.get;
-            const name = input.name?.trim();
-            const description = input.description?.trim();
-            if (!name) {
-                yield failureResult(requestId, "arion.hatch", "ARION_HATCH_FAILED", "arion.hatch requires a name");
-                return;
-            }
-            const existing = await get(name);
-            if (existing) {
-                yield failureResult(requestId, "arion.hatch", "ARION_ALREADY_EXISTS", `An arion named "${name}" already exists.`);
-                return;
-            }
-            yield successResult(requestId, "arion.hatch", {
-                mode: "guided",
-                prompt: buildGuidedHatchPrompt(name, description),
-                name,
-                ...(description ? { description } : {}),
-            });
-        },
-        "arion.create": async function* (requestId, input) {
-            const hatch = arionManager.hatch;
-            const arion = await hatch(defaultHatchConfig(input));
-            yield successResult(requestId, "arion.create", { arion });
-        },
-        "arion.become": async function* (requestId, input) {
-            const get = arionManager.get;
-            const wake = arionManager.wake;
-            const name = input.name?.trim();
-            if (!name) {
-                yield failureResult(requestId, "arion.become", "ARION_BECOME_FAILED", "arion.become requires a name");
-                return;
-            }
-            const arion = await get(name);
-            if (!arion) {
-                yield failureResult(requestId, "arion.become", "ARION_NOT_FOUND", `Arion ${name} not found`);
-                return;
-            }
-            if (arion.status === "resting") {
-                await wake(name);
-            }
-            await ctx.config?.setActiveArion?.(name);
-            const activeArion = (await ctx.config?.getActiveArion?.()) ?? name;
-            yield successResult(requestId, "arion.become", {
-                arion,
-                activeArion,
-            });
-        },
-        "arion.rest": async function* (requestId, input) {
-            const rest = arionManager.rest;
-            const name = input.name?.trim();
-            if (!name) {
-                yield failureResult(requestId, "arion.rest", "ARION_REST_FAILED", "arion.rest requires a name");
-                return;
-            }
-            await rest(name);
-            yield successResult(requestId, "arion.rest", { success: true, name });
-        },
-        "arion.wake": async function* (requestId, input) {
-            const wake = arionManager.wake;
-            const name = input.name?.trim();
-            if (!name) {
-                yield failureResult(requestId, "arion.wake", "ARION_WAKE_FAILED", "arion.wake requires a name");
-                return;
-            }
-            await wake(name);
-            yield successResult(requestId, "arion.wake", { success: true, name });
-        },
-    };
-}
-//# sourceMappingURL=arion.js.map

package/dist/headless/operations/auth.js

@@ -1,45 +0,0 @@
-import { successResult, unsupportedWhenMissing } from "./utils.js";
-export function createAuthOperationHandlers(ctx, orchestrator) {
-    const auth = ctx.auth;
-    if (!auth?.status || !auth.login || !auth.logout) {
-        return {
-            "auth.status": unsupportedWhenMissing("auth", "auth.status"),
-            "auth.login": unsupportedWhenMissing("auth", "auth.login"),
-            "auth.logout": unsupportedWhenMissing("auth", "auth.logout"),
-            "auth.clear_session": unsupportedWhenMissing("auth", "auth.clear_session"),
-            "auth.import_env_session": unsupportedWhenMissing("auth", "auth.import_env_session"),
-        };
-    }
-    return {
-        "auth.status": async function* (requestId) {
-            const result = await auth.status();
-            yield successResult(requestId, "auth.status", {
-                ...(result && typeof result === "object" ? result : {}),
-            });
-        },
-        "auth.login": async function* (requestId, input, context) {
-            yield* orchestrator.login(requestId, input, context);
-        },
-        "auth.logout": async function* (requestId, input) {
-            yield* orchestrator.logout(requestId, input);
-        },
-        "auth.clear_session": async function* (requestId) {
-            const result = await auth.clearSessionOverlay?.();
-            yield successResult(requestId, "auth.clear_session", {
-                ...(result && typeof result === "object" ? result : {}),
-            });
-        },
-        "auth.import_env_session": async function* (requestId, input) {
-            const providers = Array.isArray(input.providers)
-                ? (input.providers ?? [])
-                    .filter((value) => typeof value === "string" && value.trim().length > 0)
-                    .map((value) => value.trim())
-                : [];
-            const result = await auth.importEnvSessionOverlay?.({ providers });
-            yield successResult(requestId, "auth.import_env_session", {
-                ...(result && typeof result === "object" ? result : {}),
-            });
-        },
-    };
-}
-//# sourceMappingURL=auth.js.map

package/dist/headless/operations/client.js

@@ -1,31 +0,0 @@
-import { failureResult, successResult } from "./utils.js";
-function hasAttachedClientDirectory(localControl) {
-    return ("listAttachedClients" in localControl &&
-        typeof localControl.listAttachedClients === "function" &&
-        "listDirectClientInbox" in localControl &&
-        typeof localControl.listDirectClientInbox ===
-            "function");
-}
-export function createClientOperationHandlers(ctx) {
-    return {
-        "client.list": async function* (requestId) {
-            if (!hasAttachedClientDirectory(ctx.localControl)) {
-                yield failureResult(requestId, "client.list", "MISSING_SERVICE", "Attached local-control client directory is unavailable.");
-                return;
-            }
-            yield successResult(requestId, "client.list", {
-                clients: await ctx.localControl.listAttachedClients(),
-            });
-        },
-        "client.inbox.list": async function* (requestId, input) {
-            if (!hasAttachedClientDirectory(ctx.localControl)) {
-                yield failureResult(requestId, "client.inbox.list", "MISSING_SERVICE", "Attached local-control client inbox is unavailable.");
-                return;
-            }
-            yield successResult(requestId, "client.inbox.list", {
-                events: await ctx.localControl.listDirectClientInbox(input),
-            });
-        },
-    };
-}
-//# sourceMappingURL=client.js.map

package/dist/headless/operations/config.js

@@ -1,69 +0,0 @@
-import { failureResult, successResult, unsupportedWhenMissing } from "./utils.js";
-export function createConfigOperationHandlers(ctx) {
-    const config = ctx.config;
-    if (!config?.getTheme || !config.setTheme || !config.getAutonomy || !config.setAutonomy) {
-        return {
-            "config.theme.get": unsupportedWhenMissing("config", "config.theme.get"),
-            "config.theme.set": unsupportedWhenMissing("config", "config.theme.set"),
-            "config.autonomy.get": unsupportedWhenMissing("config", "config.autonomy.get"),
-            "config.autonomy.set": unsupportedWhenMissing("config", "config.autonomy.set"),
-        };
-    }
-    return {
-        "config.theme.get": async function* (requestId) {
-            try {
-                yield successResult(requestId, "config.theme.get", {
-                    theme: await config.getTheme(),
-                });
-            }
-            catch (error) {
-                yield failureResult(requestId, "config.theme.get", "CONFIG_THEME_GET_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-        "config.theme.set": async function* (requestId, input) {
-            const theme = input.theme?.trim();
-            if (!theme) {
-                yield failureResult(requestId, "config.theme.set", "CONFIG_THEME_SET_FAILED", "config.theme.set requires a theme");
-                return;
-            }
-            try {
-                const result = await config.setTheme(theme);
-                yield successResult(requestId, "config.theme.set", {
-                    theme,
-                    ...(result && typeof result === "object" ? result : {}),
-                });
-            }
-            catch (error) {
-                yield failureResult(requestId, "config.theme.set", "CONFIG_THEME_SET_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-        "config.autonomy.get": async function* (requestId) {
-            try {
-                yield successResult(requestId, "config.autonomy.get", {
-                    autonomy: await config.getAutonomy(),
-                });
-            }
-            catch (error) {
-                yield failureResult(requestId, "config.autonomy.get", "CONFIG_AUTONOMY_GET_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-        "config.autonomy.set": async function* (requestId, input) {
-            const autonomy = input.autonomy?.trim();
-            if (!autonomy) {
-                yield failureResult(requestId, "config.autonomy.set", "CONFIG_AUTONOMY_SET_FAILED", "config.autonomy.set requires an autonomy level");
-                return;
-            }
-            try {
-                const result = await config.setAutonomy(autonomy);
-                yield successResult(requestId, "config.autonomy.set", {
-                    autonomy,
-                    ...(result && typeof result === "object" ? result : {}),
-                });
-            }
-            catch (error) {
-                yield failureResult(requestId, "config.autonomy.set", "CONFIG_AUTONOMY_SET_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-    };
-}
-//# sourceMappingURL=config.js.map

package/dist/headless/operations/daemon.js

@@ -1,47 +0,0 @@
-import { failureResult, successResult, unsupportedWhenMissing } from "./utils.js";
-export function createDaemonOperationHandlers(ctx) {
-    const daemon = ctx.daemon;
-    if (!daemon?.start || !daemon.status || !daemon.stop || !daemon.restart) {
-        return {
-            "daemon.start": unsupportedWhenMissing("daemon", "daemon.start"),
-            "daemon.status": unsupportedWhenMissing("daemon", "daemon.status"),
-            "daemon.stop": unsupportedWhenMissing("daemon", "daemon.stop"),
-            "daemon.restart": unsupportedWhenMissing("daemon", "daemon.restart"),
-        };
-    }
-    return {
-        "daemon.start": async function* (requestId, input) {
-            try {
-                yield successResult(requestId, "daemon.start", await daemon.start(input));
-            }
-            catch (error) {
-                yield failureResult(requestId, "daemon.start", "DAEMON_START_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-        "daemon.status": async function* (requestId, input) {
-            try {
-                yield successResult(requestId, "daemon.status", await daemon.status(input));
-            }
-            catch (error) {
-                yield failureResult(requestId, "daemon.status", "DAEMON_STATUS_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-        "daemon.stop": async function* (requestId, input) {
-            try {
-                yield successResult(requestId, "daemon.stop", await daemon.stop(input));
-            }
-            catch (error) {
-                yield failureResult(requestId, "daemon.stop", "DAEMON_STOP_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-        "daemon.restart": async function* (requestId, input) {
-            try {
-                yield successResult(requestId, "daemon.restart", await daemon.restart(input));
-            }
-            catch (error) {
-                yield failureResult(requestId, "daemon.restart", "DAEMON_RESTART_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-    };
-}
-//# sourceMappingURL=daemon.js.map

package/dist/headless/operations/hook.js

@@ -1,56 +0,0 @@
-import { failureResult, successResult, unsupportedWhenMissing } from "./utils.js";
-export function createHookOperationHandlers(ctx) {
-    const hook = ctx.hook;
-    if (!hook?.extract || !hook.reflect || !hook.consolidate || !hook.ingest || !hook.harvest) {
-        return {
-            "hook.extract": unsupportedWhenMissing("hook", "hook.extract"),
-            "hook.reflect": unsupportedWhenMissing("hook", "hook.reflect"),
-            "hook.consolidate": unsupportedWhenMissing("hook", "hook.consolidate"),
-            "hook.ingest": unsupportedWhenMissing("hook", "hook.ingest"),
-            "hook.harvest": unsupportedWhenMissing("hook", "hook.harvest"),
-        };
-    }
-    return {
-        "hook.extract": async function* (requestId, input, context) {
-            try {
-                yield successResult(requestId, "hook.extract", await hook.extract(input, { signal: context?.signal }));
-            }
-            catch (error) {
-                yield failureResult(requestId, "hook.extract", "HOOK_EXTRACT_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-        "hook.reflect": async function* (requestId, input, context) {
-            try {
-                yield successResult(requestId, "hook.reflect", await hook.reflect(input, { signal: context?.signal }));
-            }
-            catch (error) {
-                yield failureResult(requestId, "hook.reflect", "HOOK_REFLECT_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-        "hook.consolidate": async function* (requestId, input, context) {
-            try {
-                yield successResult(requestId, "hook.consolidate", await hook.consolidate(input, { signal: context?.signal }));
-            }
-            catch (error) {
-                yield failureResult(requestId, "hook.consolidate", "HOOK_CONSOLIDATE_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-        "hook.ingest": async function* (requestId, input, context) {
-            try {
-                yield successResult(requestId, "hook.ingest", await hook.ingest(input, { signal: context?.signal }));
-            }
-            catch (error) {
-                yield failureResult(requestId, "hook.ingest", "HOOK_INGEST_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-        "hook.harvest": async function* (requestId, input, context) {
-            try {
-                yield successResult(requestId, "hook.harvest", await hook.harvest(input, { signal: context?.signal }));
-            }
-            catch (error) {
-                yield failureResult(requestId, "hook.harvest", "HOOK_HARVEST_FAILED", error instanceof Error ? error.message : String(error));
-            }
-        },
-    };
-}
-//# sourceMappingURL=hook.js.map

package/dist/headless/operations/index.js

@@ -1,11 +0,0 @@
-export { createArionOperationHandlers } from "./arion.js";
-export { createAuthOperationHandlers } from "./auth.js";
-export { createClientOperationHandlers } from "./client.js";
-export { createConfigOperationHandlers } from "./config.js";
-export { createMemoryOperationHandlers } from "./memory.js";
-export { createMessageOperationHandlers } from "./message.js";
-export { createModelOperationHandlers } from "./model.js";
-export { createPeerOperationHandlers } from "./peer.js";
-export { createRunOperationHandlers } from "./run.js";
-export { createSessionOperationHandlers } from "./session.js";
-//# sourceMappingURL=index.js.map

package/dist/headless/operations/memory.js

@@ -1,102 +0,0 @@
-import { failureResult, unsupportedWhenMissing, successResult } from "./utils.js";
-export function createMemoryOperationHandlers(ctx) {
-    const memoria = ctx.memoria;
-    if (!memoria) {
-        return {
-            "memory.remember": unsupportedWhenMissing("memoria", "memory.remember"),
-            "memory.recall": unsupportedWhenMissing("memoria", "memory.recall"),
-            "memory.list": unsupportedWhenMissing("memoria", "memory.list"),
-            "memory.forget": unsupportedWhenMissing("memoria", "memory.forget"),
-            "memory.recall_knowledge": unsupportedWhenMissing("memoria", "memory.recall_knowledge"),
-        };
-    }
-    return {
-        "memory.remember": async function* (requestId, input) {
-            const text = input.text?.trim();
-            if (!text) {
-                yield failureResult(requestId, "memory.remember", "MEMORY_REMEMBER_FAILED", "memory.remember requires text");
-                return;
-            }
-            const stored = await memoria.remember(text);
-            if (!stored?.id) {
-                yield failureResult(requestId, "memory.remember", "MEMORY_REMEMBER_FAILED", "Failed to store memory");
-                return;
-            }
-            const count = await memoria.count();
-            const preview = text.length > 50 ? `${text.slice(0, 50)}...` : text;
-            yield successResult(requestId, "memory.remember", {
-                success: true,
-                message: `Remembered: "${preview}"`,
-                data: { id: stored.id, count },
-            });
-        },
-        "memory.recall": async function* (requestId, input) {
-            const query = input.query?.trim();
-            if (!query) {
-                yield failureResult(requestId, "memory.recall", "MEMORY_RECALL_FAILED", "memory.recall requires a query");
-                return;
-            }
-            const result = await memoria.recall(query);
-            const memories = Array.isArray(result.memories) ? result.memories : [];
-            if (memories.length === 0) {
-                yield successResult(requestId, "memory.recall", {
-                    success: true,
-                    message: "No memories found matching your query.",
-                    count: 0,
-                    memories: [],
-                });
-                return;
-            }
-            yield successResult(requestId, "memory.recall", {
-                success: true,
-                message: `Found ${memories.length} memories:`,
-                count: memories.length,
-                memories,
-            });
-        },
-        "memory.list": async function* (requestId, input) {
-            const args = input;
-            const listed = await memoria.list({
-                ...(typeof args.limit === "number" ? { limit: args.limit } : {}),
-                ...(typeof args.offset === "number" ? { offset: args.offset } : {}),
-            });
-            const filtered = typeof args.query === "string" && args.query.trim().length > 0
-                ? listed.filter((memory) => memory.content.toLowerCase().includes(args.query.trim().toLowerCase()))
-                : listed;
-            yield successResult(requestId, "memory.list", {
-                memories: filtered,
-                count: filtered.length,
-            });
-        },
-        "memory.forget": async function* (requestId, input) {
-            const id = input.id?.trim();
-            if (!id) {
-                yield failureResult(requestId, "memory.forget", "MEMORY_FORGET_FAILED", "memory.forget requires an id");
-                return;
-            }
-            const deleted = await memoria.deleteMemory(id);
-            yield successResult(requestId, "memory.forget", {
-                success: true,
-                message: deleted ? `Deleted memory ${id}.` : `Memory ${id} not found or already deleted.`,
-                deleted,
-            });
-        },
-        "memory.recall_knowledge": async function* (requestId, input) {
-            const args = input;
-            const topic = args.topic?.trim();
-            if (!topic) {
-                yield failureResult(requestId, "memory.recall_knowledge", "MEMORY_RECALL_KNOWLEDGE_FAILED", "memory.recall_knowledge requires a topic");
-                return;
-            }
-            const tools = await memoria.recallTools({
-                query: topic,
-                ...(typeof args.limit === "number" ? { limit: args.limit } : {}),
-            });
-            yield successResult(requestId, "memory.recall_knowledge", {
-                tools,
-                count: tools.length,
-            });
-        },
-    };
-}
-//# sourceMappingURL=memory.js.map