substrate-ai 0.20.63 → 0.20.65

package/dist/index.js

@@ -1,8 +1,8 @@
 import { childLogger, createLogger, logger } from "./logger-KeHncl-f.js";
 import { assertDefined, createEventBus, createTuiApp, deepClone, formatDuration, generateId, isPlainObject, isTuiCapable, printNonTtyWarning, sleep, withRetry } from "./helpers-CElYrONe.js";
-import { AdapterRegistry, AdtError, ClaudeCodeAdapter, CodexCLIAdapter, ConfigError, ConfigIncompatibleFormatError, GeminiCLIAdapter } from "./dist-W2emvN3F.js";
+import { AdapterRegistry$1 as AdapterRegistry, AdtError$1 as AdtError, ClaudeCodeAdapter$1 as ClaudeCodeAdapter, CodexCLIAdapter$1 as CodexCLIAdapter, ConfigError$1 as ConfigError, ConfigIncompatibleFormatError$1 as ConfigIncompatibleFormatError, GeminiCLIAdapter$1 as GeminiCLIAdapter } from "./dist-K_RRWnBX.js";
 import "./adapter-registry-DXLMTmfD.js";
-import { BudgetExceededError, GitError, RecoveryError, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, WorkerError, WorkerNotFoundError } from "./errors-CKFu8YI9.js";
+import { BudgetExceededError, GitError, RecoveryError, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, WorkerError, WorkerNotFoundError } from "./errors-pSiZbn6e.js";
 
 //#region src/core/di.ts
 /**

package/dist/interactive-prompt-C7wpE4z4.js

@@ -0,0 +1,183 @@
+import { createLogger } from "./logger-KeHncl-f.js";
+import { readCurrentRunId, resolveMainRepoRoot } from "./manifest-read-DDkXC3L_.js";
+import { join } from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import * as readline from "node:readline";
+
+//#region src/modules/interactive-prompt/index.ts
+const logger = createLogger("interactive-prompt");
+const SEPARATOR = "─────────────────────────────────────────────────";
+/**
+* Write the numbered-choice prompt to stdout (AC2).
+* Called before readline to ensure the separator appears before stdin read.
+*/
+function renderPrompt(ctx) {
+	process.stdout.write(`${SEPARATOR}\n`);
+	process.stdout.write(`⚠ Halt: ${ctx.decisionType} (${ctx.severity})\n`);
+	process.stdout.write(`${SEPARATOR}\n`);
+	process.stdout.write(`${ctx.summary}\n\n`);
+	process.stdout.write(`1) Accept default: ${ctx.defaultAction}\n`);
+	process.stdout.write(`2) Retry with custom context\n`);
+	process.stdout.write(`3) Propose re-scope\n`);
+	process.stdout.write(`4) Abort run\n`);
+	process.stdout.write(`\nChoice [1]: `);
+}
+/**
+* Sanitize an ISO timestamp string for use in a filename (replace colons and dots).
+*/
+function sanitizeTimestampForFilename(iso) {
+	return iso.replace(/:/g, "-").replace(/\./g, "-");
+}
+/**
+* Resolve the notifications directory (AC8 — use resolveMainRepoRoot).
+*/
+async function resolveNotificationsDir() {
+	const repoRoot = await resolveMainRepoRoot();
+	return join(repoRoot, ".substrate", "notifications");
+}
+/**
+* Write the initial notification file BEFORE prompting (AC5).
+* Returns the file path so we can update operatorChoice after the prompt.
+*/
+async function writeNotificationFile(runId, ctx, timestamp) {
+	const notifDir = await resolveNotificationsDir();
+	await mkdir(notifDir, { recursive: true });
+	const safeTs = sanitizeTimestampForFilename(timestamp);
+	const filePath = join(notifDir, `${runId}-${safeTs}.json`);
+	const notification = {
+		runId,
+		timestamp,
+		decisionType: ctx.decisionType,
+		severity: ctx.severity,
+		context: {
+			summary: ctx.summary,
+			defaultAction: ctx.defaultAction
+		},
+		choices: ctx.choices,
+		operatorChoice: null
+	};
+	await writeFile(filePath, JSON.stringify(notification, null, 2), "utf8");
+	logger.debug({ filePath }, "notification file written");
+	return filePath;
+}
+/**
+* Update operatorChoice in the notification file after the operator responds (AC5).
+* If the file was deleted by an external monitor, swallow ENOENT and continue (AC7).
+*/
+async function updateNotificationChoice(filePath, operatorChoice) {
+	try {
+		const raw = await readFile(filePath, "utf8");
+		const parsed = JSON.parse(raw);
+		parsed.operatorChoice = operatorChoice;
+		await writeFile(filePath, JSON.stringify(parsed, null, 2), "utf8");
+		logger.debug({
+			filePath,
+			operatorChoice
+		}, "notification file updated with operator choice");
+	} catch (err) {
+		if (err.code === "ENOENT") {
+			logger.debug({ filePath }, "notification file already deleted by external monitor — continuing");
+			return;
+		}
+		logger.warn({
+			err,
+			filePath
+		}, "failed to update notification file — continuing");
+	}
+}
+/**
+* Parse a raw stdin line into a 1–4 integer choice, defaulting to 1 on failure.
+*/
+function parseChoice(raw) {
+	const trimmed = raw.trim();
+	if (trimmed === "") return 1;
+	const n = parseInt(trimmed, 10);
+	if (isNaN(n) || n < 1 || n > 4) return 1;
+	return n;
+}
+/**
+* Map a parsed choice integer to the corresponding operator action string.
+*/
+function mapChoiceToAction(choice, defaultAction) {
+	switch (choice) {
+		case 1: return defaultAction;
+		case 2: return "retry-with-custom-context";
+		case 3: return "propose-re-scope";
+		case 4: return "abort-run";
+	}
+}
+/**
+* Run the interactive prompt for a Decision Router halt.
+*
+* Workflow:
+* 1. Resolve run ID (from context or manifest-read.ts).
+* 2. Write notification file BEFORE prompting (AC5).
+* 3. If non-interactive mode, emit halt-skipped event and return default (AC4).
+* 4. If stdin is not a TTY, log warning and treat as non-interactive (defensive).
+* 5. Render the numbered-choice prompt (AC2).
+* 6. Read one line from stdin via readline.createInterface (AC3).
+* 7. Parse and return the chosen action.
+* 8. Update notification file with the operator's choice (AC5).
+*
+* @param decisionContext - Decision context from the Decision Router halt.
+* @returns The operator's chosen action string.
+*/
+async function runInteractivePrompt(decisionContext) {
+	let runId = decisionContext.runId ?? null;
+	if (!runId) try {
+		const repoRoot = await resolveMainRepoRoot();
+		runId = await readCurrentRunId(repoRoot);
+	} catch {}
+	if (!runId) runId = "unknown";
+	const timestamp = new Date().toISOString();
+	let notifPath = null;
+	try {
+		notifPath = await writeNotificationFile(runId, decisionContext, timestamp);
+	} catch (err) {
+		logger.warn({ err }, "failed to write notification file — continuing without it");
+	}
+	const isNonInteractive = process.env["SUBSTRATE_NON_INTERACTIVE"] === "true" || decisionContext.nonInteractive === true;
+	if (isNonInteractive) {
+		const haltSkippedPayload = {
+			runId,
+			decisionType: decisionContext.decisionType,
+			severity: decisionContext.severity,
+			defaultAction: decisionContext.defaultAction,
+			reason: "non-interactive: stdin prompt suppressed"
+		};
+		decisionContext.onHaltSkipped?.(haltSkippedPayload);
+		logger.debug({
+			runId,
+			decisionType: decisionContext.decisionType
+		}, "non-interactive mode: returning default action");
+		return decisionContext.defaultAction;
+	}
+	if (!process.stdin.isTTY) {
+		logger.warn({
+			runId,
+			decisionType: decisionContext.decisionType
+		}, "stdin is not a TTY — treating as non-interactive and returning default action");
+		return decisionContext.defaultAction;
+	}
+	renderPrompt(decisionContext);
+	const chosenAction = await new Promise((resolve$1) => {
+		const rl = readline.createInterface({
+			input: process.stdin,
+			output: process.stdout
+		});
+		rl.once("line", (line) => {
+			rl.close();
+			const choice = parseChoice(line);
+			resolve$1(mapChoiceToAction(choice, decisionContext.defaultAction));
+		});
+		rl.once("close", () => {
+			resolve$1(decisionContext.defaultAction);
+		});
+	});
+	if (notifPath) await updateNotificationChoice(notifPath, chosenAction);
+	return chosenAction;
+}
+
+//#endregion
+export { runInteractivePrompt };
+//# sourceMappingURL=interactive-prompt-C7wpE4z4.js.map