@nodeint/migent 0.1.4 → 0.1.6

package/dist/display.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { sessionFields } from "./session-row.js";
 const require = createRequire(import.meta.url);
 const pc = require("picocolors");
 export function printError(message) {
@@ -11,6 +12,9 @@ export function printNotice(message) {
     const prefix = tty ? pc.cyan(pc.bold("[migent] ")) : "[migent] ";
     process.stderr.write(`${prefix}${message}\n`);
 }
+export function printResumeCommand(sessionId) {
+    process.stderr.write(`Resume with:\nmigent session continue ${sessionId}\n`);
+}
 export function printCreated(paths, nextCommand) {
     process.stdout.write("Created:\n");
     for (const filePath of paths)
@@ -45,8 +49,8 @@ export function printSessions(rows) {
         return;
     }
     for (const row of rows) {
-        const [, sessionId, workflowId, status, executionId, decision, outputs, task] = row;
-        process.stdout.write(`${sessionId ?? ""}  ${workflowId ?? ""}  ${status ?? ""}  ${executionId ?? ""}  ${decision ?? ""}  ${outputs ?? ""}  ${task ?? ""}\n`);
+        const fields = sessionFields(row);
+        process.stdout.write(`${fields.session}  ${fields.workflow}  ${fields.status}  ${fields.execution}  ${fields.decision}  ${fields.outputs}  ${fields.task}\n`);
     }
 }
 export function printAgent(result, role, provider, model) {
@@ -74,13 +78,24 @@ export function printWatchSnapshot(snapshot) {
     }
     if (typeof snapshot.task === "string" && snapshot.task)
         lines.push(["task", snapshot.task]);
-    const executionId = snapshot.execution_id;
-    const executionStatus = snapshot.execution_status ?? snapshot.latest_execution_status;
-    if (typeof executionId === "string" && executionId) {
-        const value = typeof executionStatus === "string" && executionStatus
-            ? `${executionId} · ${executionStatus}`
-            : executionId;
-        lines.push(["execution", value]);
+    const running = Array.isArray(snapshot.running_stages) ? snapshot.running_stages.filter(isRecord) : [];
+    if (running.length > 0) {
+        for (const stage of running) {
+            const stageId = typeof stage.stage_id === "string" && stage.stage_id ? stage.stage_id : "stage";
+            const executionId = typeof stage.execution_id === "string" ? stage.execution_id : "";
+            const summary = typeof stage.summary === "string" && stage.summary ? ` · ${stage.summary}` : "";
+            lines.push(["running", `${stageId} · ${executionId}${summary}`]);
+        }
+    }
+    else {
+        const executionId = snapshot.execution_id;
+        const executionStatus = snapshot.execution_status ?? snapshot.latest_execution_status;
+        if (typeof executionId === "string" && executionId) {
+            const value = typeof executionStatus === "string" && executionStatus
+                ? `${executionId} · ${executionStatus}`
+                : executionId;
+            lines.push(["execution", value]);
+        }
     }
     const outcome = snapshot.outcome;
     if (isRecord(outcome) && typeof outcome.status === "string") {

package/dist/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class PromptCancelled extends Error {
+    constructor();
+}

package/dist/errors.js

@@ -0,0 +1,6 @@
+export class PromptCancelled extends Error {
+    constructor() {
+        super("Prompt cancelled.");
+        this.name = "PromptCancelled";
+    }
+}

package/dist/exits.d.ts

@@ -0,0 +1,12 @@
+export declare const EXIT_OK = 0;
+export declare const EXIT_BLOCKED = 1;
+export declare const EXIT_CONFIG = 2;
+export declare const EXIT_STAGE_FAILED = 3;
+export declare const EXIT_QUOTA = 8;
+export declare const EXIT_REVISIONS = 4;
+export declare const EXIT_DISPATCHES = 5;
+export declare const EXIT_VERIFY = 6;
+export declare const EXIT_VERIFY_FAILED = 7;
+export declare const EXIT_CANCELLED = 130;
+export declare const LOOP_EXITS: string[];
+export declare const STAGE_EXITS: string[];

package/dist/exits.js

@@ -0,0 +1,33 @@
+export const EXIT_OK = 0;
+export const EXIT_BLOCKED = 1;
+export const EXIT_CONFIG = 2;
+export const EXIT_STAGE_FAILED = 3;
+export const EXIT_QUOTA = 8;
+export const EXIT_REVISIONS = 4;
+export const EXIT_DISPATCHES = 5;
+export const EXIT_VERIFY = 6;
+export const EXIT_VERIFY_FAILED = 7;
+export const EXIT_CANCELLED = 130;
+export const LOOP_EXITS = [
+    `Exit ${EXIT_OK} when the session is completed.`,
+    `Exit ${EXIT_BLOCKED} when the session is blocked. session continue runs that stage again.`,
+    `Exit ${EXIT_CONFIG} on a configuration error.`,
+    `Exit ${EXIT_STAGE_FAILED} when a stage fails and the command does not wait. The session stays active.`,
+    `Exit ${EXIT_QUOTA} when --once or --stage hits a provider quota and does not wait. The session stays active.`,
+    `Exit ${EXIT_REVISIONS} when a route would exceed max_revisions. The session stays active.`,
+    `Exit ${EXIT_DISPATCHES} when --max-dispatches is spent. The session stays active.`,
+    `Exit ${EXIT_VERIFY} when verify fails max_verify times. The session stays active.`,
+    `Exit ${EXIT_VERIFY_FAILED} when a stage with no role fails verify. The session stays active.`,
+    `Exit ${EXIT_CANCELLED} when cancelled. session continue resumes that execution.`,
+];
+export const STAGE_EXITS = [
+    `Exit ${EXIT_OK} when the stage outcome is complete, or the session is already completed.`,
+    `Exit ${EXIT_BLOCKED} when the stage is not complete, or the session is blocked.`,
+    `Exit ${EXIT_CONFIG} on a configuration error.`,
+    `Exit ${EXIT_STAGE_FAILED} when a non-continue --once or --stage finds a failed stage with no resume marker.`,
+    `Exit ${EXIT_QUOTA} when --once or --stage hits a provider quota and does not wait.`,
+    `Exit ${EXIT_REVISIONS} when a route would exceed max_revisions. The session stays active.`,
+    `Exit ${EXIT_VERIFY} when verify fails max_verify times. The session stays active.`,
+    `Exit ${EXIT_VERIFY_FAILED} when a stage with no role fails verify. The session stays active.`,
+    `Exit ${EXIT_CANCELLED} when cancelled. session continue resumes that execution.`,
+];

package/dist/follow-log.d.ts

@@ -0,0 +1,29 @@
+export interface FollowLine {
+    line: string;
+    source: "events" | "stream";
+    path: string;
+}
+export interface StreamFollowStart {
+    offset: number;
+    /** Skip stream lines whose timestamp parses earlier than this. The floor stays for later polls. */
+    minTimestampMs: number | null;
+}
+/**
+ * Where to start reading one execution stream.
+ * `--cursor` is a byte offset into events.jsonl. Stream lines are selected by timestamp.
+ * A stream created after follow starts is not passed here: the caller reads it from offset 0.
+ */
+export declare function streamFollowStart(cursor: number | null, eventsText: string, streamSize: number): StreamFollowStart;
+export declare function includeStreamLine(line: string, minTimestampMs: number | null): boolean;
+export declare function compareFollowLines(left: FollowLine, right: FollowLine): number;
+/** Lines follow would emit for this cursor, including a stream that appeared after the start. */
+export declare function replayFollowLines(input: {
+    cursor: number | null;
+    eventsText: string;
+    streams: Array<{
+        path: string;
+        text: string;
+        appearedAfterStart?: boolean;
+    }>;
+}): string[];
+export declare function listStreamFiles(sessionDirectory: string): string[];

package/dist/follow-log.js

@@ -0,0 +1,172 @@
+import { readdirSync, statSync } from "node:fs";
+import path from "node:path";
+/**
+ * Where to start reading one execution stream.
+ * `--cursor` is a byte offset into events.jsonl. Stream lines are selected by timestamp.
+ * A stream created after follow starts is not passed here: the caller reads it from offset 0.
+ */
+export function streamFollowStart(cursor, eventsText, streamSize) {
+    if (cursor === null)
+        return { offset: streamSize, minTimestampMs: null };
+    if (cursor === 0)
+        return { offset: 0, minTimestampMs: null };
+    const anchor = firstCompleteEvent(eventsText, cursor);
+    if (anchor === null)
+        return { offset: streamSize, minTimestampMs: null };
+    const ms = Date.parse(anchor.timestamp);
+    return { offset: 0, minTimestampMs: Number.isNaN(ms) ? null : ms };
+}
+export function includeStreamLine(line, minTimestampMs) {
+    if (minTimestampMs === null)
+        return true;
+    const timestamp = eventTimestamp(line);
+    if (timestamp === null)
+        return true;
+    const ms = Date.parse(timestamp);
+    if (Number.isNaN(ms))
+        return true;
+    return ms >= minTimestampMs;
+}
+export function compareFollowLines(left, right) {
+    const a = sortKey(left);
+    const b = sortKey(right);
+    if (a.time !== b.time)
+        return a.time - b.time;
+    if (a.seq !== b.seq)
+        return a.seq - b.seq;
+    if (a.source !== b.source)
+        return a.source - b.source;
+    if (a.path < b.path)
+        return -1;
+    if (a.path > b.path)
+        return 1;
+    return 0;
+}
+/** Lines follow would emit for this cursor, including a stream that appeared after the start. */
+export function replayFollowLines(input) {
+    const eventsSize = Buffer.byteLength(input.eventsText);
+    const eventOffset = input.cursor === null ? eventsSize : input.cursor;
+    const lines = linesFromByte(input.eventsText, eventOffset).map((line) => ({
+        line,
+        source: "events",
+        path: "events.jsonl",
+    }));
+    for (const stream of input.streams) {
+        const size = Buffer.byteLength(stream.text);
+        const start = stream.appearedAfterStart
+            ? { offset: 0, minTimestampMs: null }
+            : streamFollowStart(input.cursor, input.eventsText, size);
+        for (const line of linesFromByte(stream.text, start.offset)) {
+            if (!includeStreamLine(line, start.minTimestampMs))
+                continue;
+            lines.push({ line, source: "stream", path: stream.path });
+        }
+    }
+    lines.sort(compareFollowLines);
+    return lines.map((item) => item.line);
+}
+export function listStreamFiles(sessionDirectory) {
+    const root = path.join(sessionDirectory, "executions");
+    let entries;
+    try {
+        entries = readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || (entry.name.startsWith(".") && entry.name.endsWith(".tmp")))
+            continue;
+        const stream = path.join(root, entry.name, "stream.jsonl");
+        try {
+            if (statSync(stream).isFile())
+                files.push(stream);
+        }
+        catch {
+            // This execution has no stream yet.
+        }
+    }
+    files.sort();
+    return files;
+}
+function firstCompleteEvent(eventsText, cursor) {
+    for (const entry of lineSpans(eventsText)) {
+        if (entry.start < cursor)
+            continue;
+        const timestamp = eventTimestamp(entry.line);
+        if (timestamp === null && !isEventLine(entry.line))
+            continue;
+        if (!isEventLine(entry.line))
+            continue;
+        return { timestamp: timestamp ?? "" };
+    }
+    return null;
+}
+function isEventLine(line) {
+    try {
+        const value = JSON.parse(line);
+        return isRecord(value) && typeof value.event === "string" && value.event !== "";
+    }
+    catch {
+        return false;
+    }
+}
+function eventTimestamp(line) {
+    try {
+        const value = JSON.parse(line);
+        if (!isRecord(value) || typeof value.event !== "string")
+            return null;
+        return typeof value.timestamp === "string" ? value.timestamp : "";
+    }
+    catch {
+        return null;
+    }
+}
+function sortKey(item) {
+    let time = Number.POSITIVE_INFINITY;
+    let seq = Number.POSITIVE_INFINITY;
+    try {
+        const value = JSON.parse(item.line);
+        if (isRecord(value)) {
+            if (typeof value.timestamp === "string") {
+                const parsed = Date.parse(value.timestamp);
+                if (!Number.isNaN(parsed))
+                    time = parsed;
+            }
+            if (typeof value.seq === "number" && Number.isFinite(value.seq))
+                seq = value.seq;
+        }
+    }
+    catch {
+        // Unparseable lines sort after timed events and stay in source order.
+    }
+    return { time, seq, source: item.source === "events" ? 0 : 1, path: item.path };
+}
+function linesFromByte(text, offset) {
+    const buffer = Buffer.from(text);
+    if (offset >= buffer.length || offset < 0)
+        return offset < 0 ? linesFromByte(text, 0) : [];
+    const slice = buffer.subarray(offset).toString("utf8");
+    const parts = slice.split("\n");
+    if (!slice.endsWith("\n"))
+        parts.pop();
+    return parts.filter((line) => line !== "");
+}
+function lineSpans(text) {
+    const buffer = Buffer.from(text);
+    const spans = [];
+    let lineStart = 0;
+    for (let index = 0; index < buffer.length; index += 1) {
+        if (buffer[index] !== 0x0a)
+            continue;
+        const line = buffer.subarray(lineStart, index).toString("utf8");
+        if (line !== "")
+            spans.push({ start: lineStart, line });
+        lineStart = index + 1;
+    }
+    return spans;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/fs-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function exists(filePath: string): boolean;
+export declare function isFile(filePath: string): boolean;
+export declare function isDirectory(filePath: string): boolean;

package/dist/fs-utils.js

@@ -0,0 +1,26 @@
+import { statSync } from "node:fs";
+export function exists(filePath) {
+    try {
+        statSync(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isFile(filePath) {
+    try {
+        return statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function isDirectory(filePath) {
+    try {
+        return statSync(filePath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/index.js

@@ -4,6 +4,8 @@ import { fileURLToPath } from "node:url";
 import { CommanderError } from "commander";
 import { ConfigurationError } from "@nodeint/migent-kernel";
 import { printError } from "./display.js";
+import { PromptCancelled } from "./errors.js";
+import { EXIT_CANCELLED, EXIT_CONFIG } from "./exits.js";
 import { cliHooks } from "./hooks.js";
 import { createProgram } from "./program.js";
 import { setInvocationCwd } from "./workspace.js";
@@ -20,9 +22,11 @@ export async function main(argv = process.argv.slice(2), cwd) {
         return status.code;
     }
     catch (error) {
+        if (error instanceof PromptCancelled)
+            return EXIT_CANCELLED;
         if (error instanceof ConfigurationError) {
             printError(error.message);
-            return 2;
+            return EXIT_CONFIG;
         }
         if (error instanceof CommanderError)
             return error.exitCode === 0 ? 0 : 2;

package/dist/migrate.js

@@ -1,8 +1,9 @@
-import { readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { readFileSync, readdirSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { confirm as clackConfirm, isCancel } from "@clack/prompts";
 import { SCHEMA_VERSION, documentVersion, loadYamlMapping, migrateConfig, migrateWorkflow, patchConfigText, patchWorkflowText, workflowsDirectory, ConfigurationError, } from "@nodeint/migent-kernel";
 import { printError, printNotice } from "./display.js";
+import { isDirectory, isFile } from "./fs-utils.js";
 import { adapterMap } from "./provider.js";
 const OUTDATED = "Schema is outdated. Run `migent migrate` to update.";
 export function requireCurrentSchema(workspace) {
@@ -173,19 +174,3 @@ function workflowRewrites(workspace, config, adapters) {
     }
     return rewrites;
 }
-function isFile(filePath) {
-    try {
-        return statSync(filePath).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function isDirectory(filePath) {
-    try {
-        return statSync(filePath).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}