@alisio/alisio-code 0.5.2 → 0.7.0

package/dist/analysis.d.ts

@@ -1,4 +1,4 @@
-import type { AnalysisStatus } from "@alisio/sdk";
+import type { AnalysisStatus, EngineDescriptor } from "@alisio/sdk";
 type Common = {
     db?: string;
     python?: string;
@@ -6,6 +6,10 @@ type Common = {
     config?: string;
     trustProject?: boolean;
 };
+/** `alisio forge status` reuses this for its Python lines. */
+export declare function pythonBackendDescriptors(o: Common): Promise<EngineDescriptor[]>;
+/** A fixed-width table of the backends: readiness, isolation, profiles and why not. */
+export declare function backendsTable(backends: readonly EngineDescriptor[]): string;
 /** The unified runtime state and, when Python is missing, the install guidance for this system. */
 export declare function analysisState(o: Common): Promise<{
     status: AnalysisStatus;
@@ -24,4 +28,23 @@ export declare function setupExtras(o: Common, extras: string | undefined): Prom
 export declare function setupOci(o: Common, image: string | undefined): Promise<void>;
 /** `alisio analysis sweep [--force]`: the retention sweep now (it also runs by itself, daily). */
 export declare function sweep(o: Common, force: boolean): Promise<void>;
+export interface WasmSetupDeps {
+    /** Replaceable in tests; the global `fetch` otherwise. */
+    fetch?: typeof fetch;
+    manifest?: import("@alisio/core").PyodideManifest;
+    /** Whether someone can answer a question (a terminal). */
+    interactive?: boolean;
+    ask?: (question: string) => Promise<boolean>;
+    write?: (text: string) => void;
+}
+/**
+ * `alisio analysis setup --wasm [--profile analysis|science] [--yes]`: the only place the wasm
+ * backend uses the network. Downloads the pinned Pyodide distribution into
+ * `<analysis dir>/pyodide/<version>/`, verifies every hash and size, and on any mismatch deletes
+ * what it fetched and leaves the backend not ready. It never touches the venv or the OCI image.
+ */
+export declare function setupWasm(o: Common, flags: {
+    profile?: string;
+    yes?: boolean;
+}, deps?: WasmSetupDeps): Promise<void>;
 export {};

package/dist/analysis.js

@@ -5,6 +5,7 @@
  * `python_run`: the base runtime is the discovered Python with only the standard library.
  */
 import { dirname, join } from "node:path";
+import { createInterface } from "node:readline/promises";
 async function context(o) {
     const core = await import("@alisio/core");
     const workspace = await core.findWorkspace(o.cwd ?? process.cwd());
@@ -20,9 +21,41 @@ async function context(o) {
     const oci = () => new core.OciRuntime({ ...config.analysis.oci });
     return { core, config, provenance, stateDir, manager, oci };
 }
+/** The Python backends of this configuration, described with their live readiness. */
+function describeBackends(c) {
+    const backends = c.core.createPythonBackends({
+        runtime: c.manager,
+        oci: { runtime: c.oci, mode: () => c.config.analysis.runtime },
+        wasm: { stateRoot: c.stateDir, settings: () => c.config.analysis.wasm },
+    });
+    return (signal) => c.core.describePythonBackends(backends, signal);
+}
+/** `alisio forge status` reuses this for its Python lines. */
+export async function pythonBackendDescriptors(o) {
+    return describeBackends(await context(o))();
+}
+/** A fixed-width table of the backends: readiness, isolation, profiles and why not. */
+export function backendsTable(backends) {
+    const rows = backends.map((b) => [
+        b.id.replace(/^python-/, ""),
+        b.isolation,
+        b.ready ? "ready" : "not ready",
+        b.profiles?.length ? b.profiles.join(",") : "-",
+        b.capabilities.networkDeniedByOS ? "denied" : "open",
+        b.reason ?? (b.isolation === "none" ? "host (not sandboxed)" : ""),
+    ]);
+    const head = ["BACKEND", "ISOLATION", "STATE", "PROFILES", "NETWORK", "NOTE"];
+    const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+    const line = (cells) => cells
+        .map((c, i) => c.padEnd(widths[i] ?? 0))
+        .join("  ")
+        .trimEnd();
+    return [line(head), ...rows.map(line)].join("\n");
+}
 /** The unified runtime state and, when Python is missing, the install guidance for this system. */
 export async function analysisState(o) {
-    const { core, config, provenance, stateDir, manager, oci } = await context(o);
+    const ctx = await context(o);
+    const { core, config, provenance, stateDir, manager, oci } = ctx;
     const janitor = {
         lastSweep: () => import("node:fs/promises")
             .then((fs) => fs.readFile(join(stateDir, "analysis", ".last-sweep"), "utf8"))
@@ -37,6 +70,7 @@ export async function analysisState(o) {
         runtime: manager,
         oci,
         janitor,
+        backends: describeBackends(ctx),
         enabled: config.analysis.enabled,
         readOnly: false,
     });
@@ -58,6 +92,8 @@ export async function analysisState(o) {
 export async function printAnalysisStatus(o) {
     const { status, guidance, ignored } = await analysisState(o);
     console.log(JSON.stringify(status, null, 2));
+    if (status.backends?.length)
+        process.stderr.write(`\nPython backends (analysis.runtime=${status.mode}, analysis.isolation=${status.isolation ?? "preferred"}):\n${backendsTable(status.backends)}\n`);
     if (guidance)
         process.stderr.write(`\n${guidance}\n`);
     if (status.mode === "oci" && status.oci.available === false)
@@ -143,3 +179,66 @@ export async function sweep(o, force) {
         store.close();
     }
 }
+const megabytes = (bytes) => `${Math.max(1, Math.round(bytes / (1024 * 1024)))} MB`;
+async function confirm(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        return /^y(es)?$/i.test((await rl.question(question)).trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * `alisio analysis setup --wasm [--profile analysis|science] [--yes]`: the only place the wasm
+ * backend uses the network. Downloads the pinned Pyodide distribution into
+ * `<analysis dir>/pyodide/<version>/`, verifies every hash and size, and on any mismatch deletes
+ * what it fetched and leaves the backend not ready. It never touches the venv or the OCI image.
+ */
+export async function setupWasm(o, flags, deps = {}) {
+    const profile = flags.profile ?? "analysis";
+    if (profile !== "analysis" && profile !== "science")
+        throw new Error("Choose the profile: --profile analysis (default) or --profile science");
+    const { core, stateDir } = await context(o);
+    const manifest = deps.manifest ?? core.PYODIDE_MANIFEST;
+    const write = deps.write ?? ((text) => void process.stderr.write(text));
+    const dir = core.pyodideDir(stateDir, manifest);
+    const bytes = core.pyodideDownloadSize(manifest, profile);
+    const hosts = [
+        ...new Set([...manifest.core, ...Object.values(manifest.packages)].map((f) => new URL(f.url).host)),
+    ];
+    write(`Pyodide ${manifest.version} (Python ${manifest.python}), profile ${profile}: about ${megabytes(bytes)} from ${hosts.join(", ")}.\n` +
+        `It goes to ${dir}. Every file is checked against a pinned SHA-256; this command is the only time the wasm backend uses the network.\n`);
+    if (!flags.yes) {
+        const interactive = deps.interactive ?? (!!process.stdin.isTTY && !!process.stderr.isTTY);
+        if (!interactive)
+            throw new Error("This download needs your confirmation: pass --yes in a non-interactive run.");
+        const ok = await (deps.ask ?? confirm)("Download now? [y/N] ");
+        if (!ok) {
+            write("Cancelled; nothing was downloaded.\n");
+            return;
+        }
+    }
+    const controller = new AbortController();
+    process.on("SIGINT", () => controller.abort(new Error("Interrupted")));
+    try {
+        const result = await core.installPyodide({
+            dir,
+            profile,
+            manifest,
+            signal: controller.signal,
+            ...(deps.fetch ? { fetch: deps.fetch } : {}),
+            onProgress: (e) => write(`  [${e.index}/${e.total}] ${e.file}\n`),
+        });
+        write(`Pyodide ${manifest.version} is ready (profile ${result.ok ? result.profile : profile}). ` +
+            'With analysis.runtime "auto" it is used when no container is ready; set analysis.runtime to "wasm" to require it.\n');
+    }
+    catch (error) {
+        const integrity = error instanceof core.PyodideIntegrityError;
+        write(`${error instanceof Error ? error.message : String(error)}\n` +
+            (integrity
+                ? "Nothing from this download was kept. The wasm backend is not ready.\n"
+                : "Nothing from this download was kept.\n"));
+        process.exitCode = 1;
+    }
+}

package/dist/eval.d.ts

@@ -0,0 +1,101 @@
+/**
+ * `alisio eval list|run|record|compare|variants|export` (specs/010 5.4, Phases 3-4). Every function
+ * returns the exit code and talks only through the injected `EvalEnv`, so tests drive them without
+ * a process:
+ *
+ *   0  completed (independent of which tasks passed)   1  usage or infrastructure error
+ *   2  a replay diverged from its cassette             3  `compare` of incompatible suites
+ *
+ * `record` runs each task once live and writes `<suite>/cassettes/<taskId>.cassette.jsonl`;
+ * `run --mode replay` serves those cassettes (no provider, no credentials, no network). `export`
+ * writes one local, scrubbed JSON bundle of a stored run (nothing is uploaded). Reports go to `<stateHome>/eval/<runId>/` (or `--out DIR`): report.json, report.md, runs.jsonl.
+ * A suite given with `--suite-dir` is third-party code: it needs `--yes` (or an interactive
+ * confirmation) because a subprocess is not a sandbox.
+ */
+import type { BuiltinPlugin, Config, EvalApplication } from "@alisio/core";
+import type { ModelProvider } from "@alisio/sdk";
+/** The part of the command line `eval` reads, global flags included. */
+export interface EvalFlags {
+    json?: boolean;
+    allowWrite?: boolean;
+    allowProcess?: boolean;
+    allowExternal?: boolean;
+    allowAnalysis?: boolean;
+    readOnly?: boolean;
+    disablePlugin?: string[];
+    suiteDir?: string;
+    tasks?: string;
+    k?: string;
+    seed?: string;
+    mode?: string;
+    keep?: boolean;
+    out?: string;
+    allowSuiteFull?: boolean;
+    yes?: boolean;
+    inputRate?: string;
+    outputRate?: string;
+    variants?: string;
+    md?: boolean;
+    cassetteDir?: string;
+    force?: boolean;
+}
+/** What a live run needs, resolved BEFORE any task starts (the engine takes a provider). */
+export interface EvalRuntime {
+    provider: ModelProvider;
+    /** The effective configuration (variant overrides are applied on top of it). */
+    config: Config;
+    builtins: BuiltinPlugin[];
+    /** Exact credential values of the run's provider profile (a cassette holding one is refused). */
+    secrets?: string[];
+    resolveAgent?: (app: EvalApplication, agent: string) => ReturnType<NonNullable<ResolveAgent>>;
+    close(): Promise<void>;
+}
+type ResolveAgent = NonNullable<import("@alisio/core").RunEvaluationOptions["resolveAgent"]>;
+export interface EvalEnv {
+    out(text: string): void;
+    err(text: string): void;
+    /** `<stateHome>`: reports default to `<stateDir>/eval/<runId>/`. */
+    stateDir: string;
+    /** Directory of the bundled suites: `tests/fixtures/eval` of a source checkout, absent elsewhere. */
+    bundledDir?: string;
+    interactive: boolean;
+    confirm(question: string): Promise<boolean>;
+    /**
+     * `requireProvider: false` (replay) must not fail when no provider is configured: the cassette
+     * is the provider, and the returned `provider` is then ignored.
+     */
+    openRuntime(flags: EvalFlags, options?: {
+        requireProvider?: boolean;
+    }): Promise<EvalRuntime>;
+    newRunId(): string;
+    /** Parent of the per-run temporary directories (tests); default `os.tmpdir()`. */
+    tmpRoot?: string;
+}
+export declare function evalList(env: EvalEnv, flags: EvalFlags): Promise<number>;
+export declare function evalRun(env: EvalEnv, flags: EvalFlags, suiteName: string): Promise<number>;
+/**
+ * Runs each selected task ONCE live and writes its cassette. A task whose run errored, whose
+ * recording is unstable, or whose cassette holds a secret or is over the size limits writes
+ * nothing and makes the command exit 1; the other tasks are still recorded.
+ */
+export declare function evalRecord(env: EvalEnv, flags: EvalFlags, suiteName: string): Promise<number>;
+export declare function evalCompare(env: EvalEnv, flags: EvalFlags, pathA: string, pathB: string): Promise<number>;
+export declare function evalVariants(env: EvalEnv, flags: EvalFlags, suiteName: string): Promise<number>;
+/**
+ * Writes ONE shareable JSON bundle `{schemaVersion, report, runs, markdown}` of the stored run
+ * `<stateDir>/eval/<runId>/`, scrubbed of absolute paths and secrets. A secret hit refuses it
+ * (exit 1). The file is local: nothing is uploaded.
+ */
+export declare function evalExport(env: EvalEnv, flags: EvalFlags, runId: string): Promise<number>;
+type CliAppOptions = import("@alisio/core").AppOptions;
+/**
+ * The real environment of `alisio eval`: the provider is resolved from the same sources as
+ * `alisio run` (flags, saved profile, trusted config) through a throwaway Application that only
+ * lends its provider and configuration. It does not carry the invoker's `--read-only`, which
+ * would stop the provider plugins from loading; the permissions the runs get come from
+ * `InvokerPermissions` instead. Its in-memory database never touches the user's sessions.
+ */
+export declare function realEvalEnv(appOptions: (flags: EvalFlags) => Promise<CliAppOptions>, defaults: () => Promise<{
+    builtins: BuiltinPlugin[];
+}>): Promise<EvalEnv>;
+export {};