@nodeint/migent 0.1.3 → 0.1.5

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;
-    }
-}