@alphafox/cli 0.3.8 → 0.3.10

package/dist/cache/clean.d.ts

@@ -0,0 +1 @@
+export declare function removeCacheRoot(directory: string, env?: NodeJS.ProcessEnv): void;

package/dist/cache/clean.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeCacheRoot = removeCacheRoot;
+const node_fs_1 = require("node:fs");
+const paths_1 = require("./paths");
+function removeCacheRoot(directory, env = process.env) {
+    (0, paths_1.assertSafeCacheRoot)(directory, env);
+    if (!(0, node_fs_1.existsSync)(directory)) {
+        return;
+    }
+    (0, node_fs_1.rmSync)(directory, { recursive: true, force: true });
+}

package/dist/cache/inspect.d.ts

@@ -0,0 +1,7 @@
+export interface DirectoryUsage {
+    readonly path: string;
+    readonly exists: boolean;
+    readonly bytes: number;
+    readonly files: number;
+}
+export declare function inspectDirectory(path: string): DirectoryUsage;

package/dist/cache/inspect.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectDirectory = inspectDirectory;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function inspectDirectory(path) {
+    if (!(0, node_fs_1.existsSync)(path)) {
+        return { path, exists: false, bytes: 0, files: 0 };
+    }
+    const root = (0, node_fs_1.statSync)(path);
+    if (root.isFile()) {
+        return { path, exists: true, bytes: root.size, files: 1 };
+    }
+    let bytes = 0;
+    let files = 0;
+    const walk = (dir) => {
+        for (const entry of (0, node_fs_1.readdirSync)(dir, { withFileTypes: true })) {
+            const next = (0, node_path_1.join)(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(next);
+                continue;
+            }
+            if (entry.isFile()) {
+                files += 1;
+                bytes += (0, node_fs_1.statSync)(next).size;
+            }
+        }
+    };
+    walk(path);
+    return { path, exists: true, bytes, files };
+}

package/dist/cache/paths.d.ts

@@ -0,0 +1,5 @@
+/** Remind Agents to offer cleanup at or above this tape-cache size. */
+export declare const TAPE_CACHE_REMIND_BYTES: number;
+export declare function resolveTapeCacheDir(env?: NodeJS.ProcessEnv): string;
+export declare function resolveRuntimeCacheRoot(env?: NodeJS.ProcessEnv): string;
+export declare function assertSafeCacheRoot(directory: string, env?: NodeJS.ProcessEnv): void;

package/dist/cache/paths.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TAPE_CACHE_REMIND_BYTES = void 0;
+exports.resolveTapeCacheDir = resolveTapeCacheDir;
+exports.resolveRuntimeCacheRoot = resolveRuntimeCacheRoot;
+exports.assertSafeCacheRoot = assertSafeCacheRoot;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+/** Remind Agents to offer cleanup at or above this tape-cache size. */
+exports.TAPE_CACHE_REMIND_BYTES = 512 * 1024 * 1024;
+function resolveTapeCacheDir(env = process.env) {
+    const override = env.ALPHAFOX_TAPE_CACHE_DIR?.trim();
+    if (override) {
+        return (0, node_path_1.resolve)(override);
+    }
+    return (0, node_path_1.resolve)((0, node_path_1.join)((0, node_os_1.homedir)(), ".alphafox", "cache", "engine-backtest"));
+}
+function resolveRuntimeCacheRoot(env = process.env) {
+    const override = env.ALPHAFOX_BACKTEST_RUNTIME_CACHE_DIR?.trim();
+    if (override) {
+        return (0, node_path_1.resolve)(override);
+    }
+    const xdg = env.XDG_CACHE_HOME?.trim();
+    return (0, node_path_1.resolve)((0, node_path_1.join)(xdg || (0, node_path_1.join)((0, node_os_1.homedir)(), ".cache"), "alphafox", "engine-backtest"));
+}
+function assertSafeCacheRoot(directory, env = process.env) {
+    const resolved = (0, node_path_1.resolve)(directory);
+    const tape = resolveTapeCacheDir(env);
+    const runtime = resolveRuntimeCacheRoot(env);
+    if (resolved === tape || resolved === runtime) {
+        return;
+    }
+    if ((0, node_path_1.basename)(resolved) === "engine-backtest") {
+        return;
+    }
+    throw Object.assign(new Error(`Refusing to touch cache directory ${resolved}`), {
+        type: "usage",
+        subtype: "cache_root_unsafe",
+        status: 400,
+    });
+}

package/dist/cache/run-command.d.ts

@@ -0,0 +1,7 @@
+export interface CacheCliFlags {
+    readonly format: "json" | "jsonl" | "text";
+    readonly yes: boolean;
+    readonly dryRun: boolean;
+    readonly jq?: string;
+}
+export declare function cmdCache(args: string[], flags: CacheCliFlags, env?: NodeJS.ProcessEnv): Promise<number>;

package/dist/cache/run-command.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdCache = cmdCache;
+const envelope_1 = require("../envelope");
+const clean_1 = require("./clean");
+const inspect_1 = require("./inspect");
+const paths_1 = require("./paths");
+async function cmdCache(args, flags, env = process.env) {
+    const sub = args[0];
+    if (sub === "status" || !sub || sub === "help" || sub === "--help" || sub === "-h") {
+        if (sub === "help" || sub === "--help" || sub === "-h") {
+            (0, envelope_1.writeSuccess)({
+                name: "cache",
+                usage: [
+                    "alphafox cache status",
+                    "alphafox cache clean [--tape|--runtime|--all] [--yes|--dry-run]",
+                ],
+            }, { format: flags.format, jq: flags.jq });
+            return 0;
+        }
+        const tape = (0, inspect_1.inspectDirectory)((0, paths_1.resolveTapeCacheDir)(env));
+        const runtime = (0, inspect_1.inspectDirectory)((0, paths_1.resolveRuntimeCacheRoot)(env));
+        (0, envelope_1.writeSuccess)({
+            tape: { ...tape, large: tape.bytes >= paths_1.TAPE_CACHE_REMIND_BYTES },
+            runtime,
+            remindAfterBytes: paths_1.TAPE_CACHE_REMIND_BYTES,
+            totalBytes: tape.bytes + runtime.bytes,
+        }, { format: flags.format, jq: flags.jq });
+        return 0;
+    }
+    if (sub === "clean") {
+        const rest = args.slice(1);
+        const all = rest.includes("--all");
+        const runtimeOnly = rest.includes("--runtime");
+        const tapeOnly = rest.includes("--tape") || (!all && !runtimeOnly);
+        const clearTape = all || tapeOnly;
+        const clearRuntime = all || runtimeOnly;
+        const tapePath = (0, paths_1.resolveTapeCacheDir)(env);
+        const runtimePath = (0, paths_1.resolveRuntimeCacheRoot)(env);
+        const tapeBefore = (0, inspect_1.inspectDirectory)(tapePath);
+        const runtimeBefore = (0, inspect_1.inspectDirectory)(runtimePath);
+        if (flags.dryRun) {
+            (0, envelope_1.writeSuccess)({
+                dryRun: true,
+                cleared: [
+                    ...(clearTape ? ["tape"] : []),
+                    ...(clearRuntime ? ["runtime"] : []),
+                ],
+                tape: tapeBefore,
+                runtime: runtimeBefore,
+            }, { format: flags.format, jq: flags.jq });
+            return 0;
+        }
+        if (!flags.yes) {
+            (0, envelope_1.writeError)({
+                type: "confirmation",
+                subtype: "yes_required",
+                message: "Cleaning local backtest cache requires --yes (or --dry-run).",
+                status: 400,
+            });
+        }
+        if (clearTape) {
+            (0, clean_1.removeCacheRoot)(tapePath, env);
+        }
+        if (clearRuntime) {
+            (0, clean_1.removeCacheRoot)(runtimePath, env);
+        }
+        (0, envelope_1.writeSuccess)({
+            dryRun: false,
+            cleared: [
+                ...(clearTape ? ["tape"] : []),
+                ...(clearRuntime ? ["runtime"] : []),
+            ],
+            tape: (0, inspect_1.inspectDirectory)(tapePath),
+            runtime: (0, inspect_1.inspectDirectory)(runtimePath),
+            bytesFreed: (clearTape ? tapeBefore.bytes : 0) +
+                (clearRuntime ? runtimeBefore.bytes : 0),
+        }, { format: flags.format, jq: flags.jq });
+        return 0;
+    }
+    (0, envelope_1.writeError)({
+        type: "usage",
+        message: "Usage: alphafox cache status|clean",
+    });
+}