@aria-cli/cli 1.0.51 → 1.0.54

package/dist/entrypoints/headless-stdio.js

@@ -1,25 +0,0 @@
-import { startHeadlessStdioServer } from "../headless/stdio-server.js";
-function parseHeadlessArgs(argv) {
-    let arionName;
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        if (arg === "--arion") {
-            const next = argv[i + 1];
-            if (!next)
-                throw new Error("--arion requires a value");
-            arionName = next;
-            i += 1;
-            continue;
-        }
-        throw new Error(`[aria] Unknown internal headless-stdio arg: ${arg}`);
-    }
-    return { arionName };
-}
-export async function runHeadlessStdioEntrypoint(argv) {
-    const parsed = parseHeadlessArgs(argv);
-    await startHeadlessStdioServer({
-        cwd: process.cwd(),
-        arionName: parsed.arionName,
-    });
-}
-//# sourceMappingURL=headless-stdio.js.map

package/dist/entrypoints/interactive.js

@@ -1,80 +0,0 @@
-import { ArionManager, ArionStorage } from "@aria-cli/aria";
-import { Memoria } from "@aria-cli/memoria";
-import { getCliModels } from "@aria-cli/models";
-import { createAttachedCliContext } from "../cli-context.js";
-import { getAriaDir } from "../config.js";
-import { ensureDaemon } from "../ensure-daemon.js";
-import { startInkRepl } from "../ink-repl.js";
-import { attachExistingLocalControlClient } from "../local-control-client.js";
-import { SessionHistory } from "../history/index.js";
-import { ArionSession } from "../session.js";
-async function recallUserName(memoria) {
-    try {
-        const raw = memoria.storage?.getConfigValue?.("user_profile");
-        return raw ? (JSON.parse(raw).name ?? null) : null;
-    }
-    catch {
-        return null;
-    }
-}
-export async function runInteractiveEntrypoint(invocation) {
-    const ariaHome = getAriaDir();
-    const cli = await createAttachedCliContext();
-    await ensureDaemon(cli);
-    const attached = await attachExistingLocalControlClient({
-        ariaHome,
-        clientKind: "tui",
-    });
-    if (!attached) {
-        throw new Error("[aria] Attached REPL requires an existing local-control runtime");
-    }
-    const memoriaPath = process.env.ARIA_MEMORY_PATH || `${cli.ariaDir}/arions/ARIA/memory.db`;
-    const memoria = new Memoria({ path: memoriaPath, router: cli.router });
-    memoria.initialize().catch((error) => {
-        console.debug(`[aria] Memoria background init failed (will retry on use): ${error?.message ?? error}`);
-    });
-    const aria = {
-        components: { memoria },
-        recallUserName: () => recallUserName(memoria),
-        shutdown: async () => {
-            await memoria.close();
-            await cli.pool.closeAll();
-        },
-    };
-    const storage = new ArionStorage(cli.ariaDir);
-    const manager = new ArionManager(storage, cli.memoriaFactory);
-    await manager.initialize();
-    manager.setRouter(cli.router);
-    const activeArion = cli.config.activeArion?.trim() || "ARIA";
-    const historyPath = SessionHistory.resolvePerArionPath(cli.ariaDir, activeArion);
-    SessionHistory.migrateJsonlLogs(cli.ariaDir, activeArion);
-    const history = new SessionHistory(historyPath);
-    const inputHistory = history.getInputHistory(100);
-    const appendInputHistory = (value) => history.addInputHistory(value);
-    let resolvedSessionId;
-    if (invocation.resumeSessionId) {
-        const found = history.findSessionByPrefix(invocation.resumeSessionId);
-        if (!found) {
-            throw new Error(`Error: No session found matching \"${invocation.resumeSessionId}\"`);
-        }
-        resolvedSessionId = found;
-    }
-    else if (invocation.continueLatest) {
-        const latest = history.listSessions(1);
-        if (latest.length === 0) {
-            throw new Error("Error: No recent sessions to continue");
-        }
-        resolvedSessionId = latest[0]?.id;
-    }
-    const session = new ArionSession({
-        manager,
-        router: cli.router,
-        memoria,
-        onArionRest: async () => { },
-    });
-    await session.initialize(cli.config.activeArion);
-    const cachedUserName = await recallUserName(memoria);
-    const initialModelSnapshot = await attached.control.getModelSnapshot?.().catch(() => undefined);
-    await startInkRepl(session, manager, cli.router, aria, attached, cli, inputHistory, appendInputHistory, history, invocation.prompt, cachedUserName, resolvedSessionId, initialModelSnapshot?.models ?? getCliModels(), undefined, cli.credentialHints, cli.authResolver);
-}
-//# sourceMappingURL=interactive.js.map

package/dist/event-loop-watchdog.js

@@ -1,73 +0,0 @@
-const WATCHDOG_INTERVAL_MS = 500;
-const DEFAULT_EVENT_LOOP_WATCHDOG_THRESHOLD_MS = 2_000;
-/**
- * Safety net for Linux where performance.now() (CLOCK_MONOTONIC) includes
- * sleep time. On macOS, performance.now() (mach_absolute_time) already
- * excludes sleep, so this threshold is never reached.
- */
-const CPU_ACTIVITY_RATIO_THRESHOLD = 0.05;
-// ---------------------------------------------------------------------------
-// Phase tracker — lightweight global that records which operation is in
-// progress so the watchdog can report WHERE a stall occurred.
-// ---------------------------------------------------------------------------
-const _phaseGlobal = globalThis;
-/**
- * Set the current phase label. The watchdog reads this on stall detection.
- * Call `clearStallPhase()` when the operation completes.
- */
-export function setStallPhase(label) {
-    _phaseGlobal.__aria_stall_phase = label;
-    _phaseGlobal.__aria_stall_phase_ts = performance.now();
-}
-export function clearStallPhase() {
-    _phaseGlobal.__aria_stall_phase = undefined;
-    _phaseGlobal.__aria_stall_phase_ts = undefined;
-}
-/** Read current phase (used by the watchdog callback). */
-export function getStallPhase() {
-    const label = _phaseGlobal.__aria_stall_phase;
-    const ts = _phaseGlobal.__aria_stall_phase_ts;
-    if (!label || typeof ts !== "number")
-        return undefined;
-    return { label, ageMs: performance.now() - ts };
-}
-/**
- * Detects event loop stalls by measuring time between setInterval ticks.
- *
- * Uses performance.now() (monotonic clock) as the primary measurement.
- * On macOS this clock does NOT advance during sleep (mach_absolute_time),
- * eliminating sleep false-positives structurally. On Linux, CLOCK_MONOTONIC
- * does include sleep time, so a secondary CPU-usage ratio check filters
- * those out: if wall-clock jumped but CPU was idle, the process was
- * suspended, not blocked.
- */
-export function startEventLoopWatchdog(opts) {
-    const thresholdMs = opts.thresholdMs ?? DEFAULT_EVENT_LOOP_WATCHDOG_THRESHOLD_MS;
-    let lastTick = performance.now();
-    let lastCpu = process.cpuUsage();
-    const interval = setInterval(() => {
-        const now = performance.now();
-        const delta = now - lastTick;
-        const cpuDelta = process.cpuUsage(lastCpu);
-        lastTick = now;
-        lastCpu = process.cpuUsage();
-        if (delta > thresholdMs) {
-            // CPU delta is in microseconds — convert to ms for comparison.
-            const cpuMs = (cpuDelta.user + cpuDelta.system) / 1000;
-            const cpuRatio = cpuMs / delta;
-            if (cpuRatio < CPU_ACTIVITY_RATIO_THRESHOLD) {
-                // Clock advanced but CPU was idle → OS sleep/suspend (Linux path).
-                opts.onSleep?.(delta);
-            }
-            else {
-                opts.onStall(delta);
-            }
-        }
-    }, WATCHDOG_INTERVAL_MS);
-    if (typeof interval === "object" && interval !== null && "unref" in interval) {
-        interval.unref();
-    }
-    return () => clearInterval(interval);
-}
-export { DEFAULT_EVENT_LOOP_WATCHDOG_THRESHOLD_MS, WATCHDOG_INTERVAL_MS };
-//# sourceMappingURL=event-loop-watchdog.js.map