@alisio/core 0.5.2 → 0.7.0

package/dist/runtime/process.js

@@ -129,7 +129,7 @@ export async function runProcess(command, args, options) {
             written += chunk.byteLength;
         };
     };
-    const consume = (stream, logPath) => new Promise((resolveText, reject) => {
+    const consume = (stream, name, logPath) => new Promise((resolveText, reject) => {
         const decoder = new TextDecoder();
         const log = logger(logPath);
         let text = "", done = false;
@@ -155,7 +155,7 @@ export async function runProcess(command, args, options) {
             if (tailMode) {
                 const live = decoder.decode(value, { stream: true });
                 if (live)
-                    options.onData?.(live);
+                    options.onData?.(live, name);
                 tail.push(value);
                 tailBytes += value.byteLength;
                 while (tailBytes > max && tail.length) {
@@ -178,7 +178,7 @@ export async function runProcess(command, args, options) {
             const chunk = decoder.decode(slice, { stream: true });
             text += chunk;
             if (chunk)
-                options.onData?.(chunk);
+                options.onData?.(chunk, name);
             if (value.byteLength > remaining) {
                 truncated = true;
                 kill();
@@ -191,8 +191,8 @@ export async function runProcess(command, args, options) {
     });
     try {
         const [stdout, stderr, exitCode] = await Promise.all([
-            consume(child.stdout, options.logFiles?.stdout),
-            consume(child.stderr, options.logFiles?.stderr),
+            consume(child.stdout, "stdout", options.logFiles?.stdout),
+            consume(child.stderr, "stderr", options.logFiles?.stderr),
             exited,
         ]);
         signal.throwIfAborted();

package/dist/runtime/store.d.ts

@@ -46,6 +46,17 @@ export declare class SQLiteStore implements SessionStore {
         runId?: string;
         startedAt?: number;
     }>;
+    /**
+     * Files the nested `write` calls of Forja executions of a session touched (D-31): one entry per
+     * journaled call that did not fail, with the tool call (`js_run`/`python_run`) that ran it so the
+     * panel can attach the run. `paths` are the absolute paths the gate resolved. Oldest first.
+     */
+    forgeWriteCalls(session: string): Array<{
+        toolCallId: string;
+        paths: string[];
+        runId?: string;
+        startedAt?: number;
+    }>;
     /** Rich (ui/image) parts persist as part of the serialized result and replay verbatim. */
     callResult(id: string, callId: string): ToolResult | undefined;
     reconcile(id: string, acknowledge?: boolean): void;

package/dist/runtime/store.js

@@ -1,4 +1,5 @@
 import { textResult, } from "@alisio/sdk";
+import { newUuid } from "./ids.js";
 import { isProcessAlive } from "./process.js";
 import { openDatabase } from "./sqlite.js";
 const alive = isProcessAlive;
@@ -231,6 +232,86 @@ export class SQLiteStore {
                 add("owner_pid", "INTEGER");
                 this.db.exec("INSERT OR IGNORE INTO schema_migrations VALUES(8)");
             });
+        if (!has(9))
+            this.db.transaction(() => {
+                // v9 (additive): Forja journal (`forge_executions`, `forge_calls`) and the small JSON state
+                // shared across executions (`forge_state`). Only hashes of inputs are stored, never the
+                // inputs or results themselves. `owner_pid` lets a restart tell its own dead executions
+                // from another live process's.
+                this.db.exec(`CREATE TABLE IF NOT EXISTS forge_executions(
+            id TEXT PRIMARY KEY,
+            root_session_id TEXT NOT NULL,
+            session_id TEXT NOT NULL,
+            tool_call_id TEXT NOT NULL,
+            engine TEXT NOT NULL,
+            isolation TEXT NOT NULL,
+            selection_reason TEXT NOT NULL,
+            status TEXT NOT NULL,
+            code_sha256 TEXT NOT NULL,
+            started_at INTEGER NOT NULL, ended_at INTEGER,
+            metrics_json TEXT,
+            error_code TEXT,
+            termination_unconfirmed INTEGER NOT NULL DEFAULT 0,
+            analysis_execution_id TEXT REFERENCES analysis_executions(id),
+            owner_pid INTEGER);
+          CREATE INDEX IF NOT EXISTS forge_executions_root
+            ON forge_executions(root_session_id, started_at);
+          CREATE TABLE IF NOT EXISTS forge_calls(
+            execution_id TEXT NOT NULL REFERENCES forge_executions(id),
+            call_id TEXT NOT NULL,
+            tool_name TEXT NOT NULL,
+            effect TEXT NOT NULL,
+            status TEXT NOT NULL,
+            duration_ms INTEGER,
+            input_sha256 TEXT NOT NULL,
+            error_code TEXT,
+            paths_json TEXT,
+            PRIMARY KEY(execution_id, call_id));
+          CREATE INDEX IF NOT EXISTS forge_calls_execution
+            ON forge_calls(execution_id, call_id);
+          CREATE TABLE IF NOT EXISTS forge_state(
+            root_session_id TEXT NOT NULL,
+            key TEXT NOT NULL,
+            value_json TEXT NOT NULL,
+            revision INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL,
+            PRIMARY KEY(root_session_id, key));
+          INSERT OR IGNORE INTO schema_migrations VALUES(9);`);
+            });
+        if (!has(10)) {
+            // v10: `analysis_executions.runtime` admits `wasm` (the Pyodide backend). SQLite cannot alter
+            // a CHECK, so the table is rebuilt with the official recipe: foreign keys off, copy, drop,
+            // rename. Rows, ids and the artifacts that point at them are untouched.
+            this.db.exec("PRAGMA foreign_keys=OFF");
+            try {
+                this.db.transaction(() => {
+                    this.db.exec(`CREATE TABLE analysis_executions_v10(
+              id TEXT PRIMARY KEY,
+              session TEXT NOT NULL,
+              root_session TEXT NOT NULL,
+              workspace TEXT NOT NULL,
+              run_id TEXT, call_id TEXT,
+              runtime TEXT NOT NULL CHECK(runtime IN ('managed','oci','wasm')),
+              status TEXT NOT NULL CHECK(status IN ('running','completed','failed','cancelled','timed_out')),
+              script_sha256 TEXT NOT NULL,
+              exit_code INTEGER, error TEXT,
+              rel_dir TEXT NOT NULL,
+              rerun_of TEXT,
+              created_at INTEGER NOT NULL, ended_at INTEGER);
+            INSERT INTO analysis_executions_v10 SELECT id,session,root_session,workspace,run_id,call_id,
+              runtime,status,script_sha256,exit_code,error,rel_dir,rerun_of,created_at,ended_at
+              FROM analysis_executions;
+            DROP TABLE analysis_executions;
+            ALTER TABLE analysis_executions_v10 RENAME TO analysis_executions;
+            CREATE INDEX IF NOT EXISTS analysis_executions_session
+              ON analysis_executions(root_session, created_at);
+            INSERT OR IGNORE INTO schema_migrations VALUES(10);`);
+                });
+            }
+            finally {
+                this.db.exec("PRAGMA foreign_keys=ON");
+            }
+        }
     }
     /**
      * The root of a session (itself for roots), following `parent_id`. Unknown ids are their own
@@ -247,7 +328,7 @@ export class SQLiteStore {
         return current;
     }
     create(workspace, provider, model) {
-        const id = crypto.randomUUID();
+        const id = newUuid();
         const now = Date.now();
         this.db
             .prepare("INSERT INTO sessions(id,workspace,provider,model,created_at,updated_at) VALUES(?,?,?,?,?,?)")
@@ -287,7 +368,7 @@ export class SQLiteStore {
             .map((r) => this.row(r));
     }
     createChild(record) {
-        const id = record.id ?? crypto.randomUUID();
+        const id = record.id ?? newUuid();
         const now = Date.now();
         this.db
             .prepare(`INSERT INTO sessions(id,workspace,provider,model,parent_id,depth,agent,status,title,usage,options,created_at,updated_at)
@@ -433,6 +514,29 @@ export class SQLiteStore {
             ...(row.started_at != null ? { startedAt: Number(row.started_at) } : {}),
         }));
     }
+    /**
+     * Files the nested `write` calls of Forja executions of a session touched (D-31): one entry per
+     * journaled call that did not fail, with the tool call (`js_run`/`python_run`) that ran it so the
+     * panel can attach the run. `paths` are the absolute paths the gate resolved. Oldest first.
+     */
+    forgeWriteCalls(session) {
+        const rows = this.db
+            .prepare(`SELECT e.tool_call_id AS tool_call_id, c.paths_json AS paths_json,
+                t.run_id AS run_id, t.started_at AS started_at
+         FROM forge_calls c
+         JOIN forge_executions e ON e.id = c.execution_id
+         LEFT JOIN tool_calls t ON t.session = e.session_id AND t.call_id = e.tool_call_id
+         WHERE e.session_id = ? AND c.effect = 'write' AND c.status != 'failed'
+           AND c.paths_json IS NOT NULL
+         ORDER BY t.started_at, c.rowid`)
+            .all(session);
+        return rows.map((row) => ({
+            toolCallId: row.tool_call_id,
+            paths: JSON.parse(row.paths_json),
+            ...(row.run_id ? { runId: row.run_id } : {}),
+            ...(row.started_at != null ? { startedAt: Number(row.started_at) } : {}),
+        }));
+    }
     /** Rich (ui/image) parts persist as part of the serialized result and replay verbatim. */
     callResult(id, callId) {
         const row = this.db

package/dist/tools/analysis.d.ts

@@ -5,6 +5,10 @@ import type { AnalysisRerun } from "../analysis/rerun.ts";
 import { type AnalysisRuntimeManager } from "../analysis/runtime-manager.ts";
 import { type ArtifactStore } from "../artifacts/store.ts";
 import type { ToolRegistry } from "../core/registry.ts";
+import type { ExecutionKernel } from "../forge/kernel.ts";
+import { type IsolationPolicy, type PythonRuntimeSetting } from "../forge/python/backend-selector.ts";
+import type { PyodideBackendDeps } from "../forge/python/pyodide-backend.ts";
+import type { EngineRegistry } from "../forge/registry.ts";
 export declare const NOT_SANDBOXED = "Managed Python is not a sandbox: the script runs with your user permissions and can read your files and use the network.";
 export interface AnalysisLimits {
     timeoutMs: number;
@@ -17,13 +21,30 @@ export interface AnalysisToolDeps {
     jobs: AnalysisJobs;
     /** Discovery (`interpreter`) and, for the optional extras, `hasExtras` / `installExtras`. */
     runtime: Pick<AnalysisRuntimeManager, "interpreter"> & Partial<Pick<AnalysisRuntimeManager, "hasExtras" | "installExtras">>;
-    /** Container mode (`analysis.runtime: "oci"`), read when each call starts. */
+    /** `analysis.runtime` and the container runtime, read when each call starts. */
     oci?: {
-        mode(): "managed" | "oci";
+        mode(): PythonRuntimeSetting;
         runtime(): OciRuntime;
     };
+    /** `analysis.isolation`, read when each call starts (`preferred` when absent). */
+    isolation?: () => IsolationPolicy;
+    /** The Pyodide backend (`analysis.runtime: "wasm"`, and a candidate of `auto`). */
+    wasm?: PyodideBackendDeps;
     /** Rerun of an earlier execution (`rerunOf`). */
     rerun?: AnalysisRerun;
+    /**
+     * The Forja kernel and engine registry shared with `js_run` (one journal, one state store). When
+     * absent the tool builds a private kernel over the jobs' database.
+     */
+    forge?: {
+        kernel: ExecutionKernel;
+        engines: EngineRegistry;
+    };
+    /**
+     * The verified Forja scratchpad of a session; undefined while there is none (Forja off, or
+     * `--read-only`). It enables `codePath` and is exposed to the script read-only.
+     */
+    scratchpad?: (session: string) => Promise<string | undefined>;
     /** Datasets of the session: `inputs: [{ datasetId }]` copies the dataset's SQLite file. */
     datasets?: DatasetService;
     rootOf: (sessionId: string) => string;
@@ -33,5 +54,7 @@ export interface AnalysisToolDeps {
         candidates: boolean;
         extras: string[];
     };
+    /** Whether `forge_guide` exists now; error results then point at `python.environment` (spec §8.4). */
+    guideHints?: () => boolean;
 }
 export declare function registerAnalysisTools(registry: ToolRegistry, deps: AnalysisToolDeps): void;