@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

package/dist/builtin/workflows/src/shared/schema-introspection.ts

@@ -1,111 +0,0 @@
-/**
- * schema-introspection — single adapter between TypeBox input/output schemas
- * and the legacy normalized field descriptor (`WorkflowInputEntry`) consumed by
- * the inputs picker UI, validation, dispatch, and render paths.
- *
- * Authors declare inputs/outputs with TypeBox schemas (`Type.String`,
- * `Type.Number`, `Type.Union([...literals])`, …). The many UI/render/dispatch
- * surfaces still want a flat `{ type, choices?, default?, required?,
- * description? }` view; rather than rewrite all of them, they derive that view
- * from a TypeBox schema through this module.
- */
-
-import {
-	IsAny,
-	IsArray,
-	IsBoolean,
-	IsInteger,
-	IsLiteralString,
-	IsNumber,
-	IsObject,
-	IsOptional,
-	IsString,
-	IsUnion,
-	type TSchema,
-} from "typebox";
-import type { WorkflowInputEntry } from "../extension/render-result.js";
-
-/** Field-kind label expected by the legacy descriptor consumers. */
-export type SchemaFieldKind = "text" | "number" | "integer" | "boolean" | "select" | "object" | "array" | "unknown";
-
-interface SchemaMeta {
-	readonly default?: unknown;
-	readonly description?: string;
-	readonly anyOf?: readonly TSchema[];
-	readonly const?: unknown;
-}
-
-function meta(schema: TSchema): SchemaMeta {
-	return schema as unknown as SchemaMeta;
-}
-
-/** True when every member of a union is a string literal. */
-function isStringLiteralUnion(schema: TSchema): boolean {
-	if (!IsUnion(schema)) return false;
-	const members = meta(schema).anyOf ?? [];
-	return members.length > 0 && members.every((m) => IsLiteralString(m));
-}
-
-/** Map a TypeBox schema to the legacy field-kind label. */
-export function schemaFieldKind(schema: TSchema): SchemaFieldKind {
-	if (isStringLiteralUnion(schema)) return "select";
-	if (IsLiteralString(schema)) return "text";
-	if (IsString(schema)) return "text";
-	if (IsInteger(schema)) return "integer";
-	if (IsNumber(schema)) return "number";
-	if (IsBoolean(schema)) return "boolean";
-	if (IsObject(schema)) return "object";
-	if (IsArray(schema)) return "array";
-	if (IsAny(schema)) return "unknown";
-	return "unknown";
-}
-
-/** Declared default value (`schema.default`), or undefined when none. */
-export function schemaDefault(schema: TSchema): unknown {
-	return meta(schema).default;
-}
-
-/** Declared description, or undefined. */
-export function schemaDescription(schema: TSchema): string | undefined {
-	return meta(schema).description;
-}
-
-/** Allowed string values for a string-literal union, else undefined. */
-export function schemaChoices(schema: TSchema): readonly string[] | undefined {
-	if (!isStringLiteralUnion(schema)) return undefined;
-	const members = meta(schema).anyOf ?? [];
-	return members.map((m) => String(meta(m).const));
-}
-
-/**
- * A field is "required" in the picker/validation sense — i.e. the caller MUST
- * supply it — when it is neither wrapped in `Type.Optional(...)` nor carries a
- * `default`. A defaulted input is a required KEY at the type level (it is always
- * present after defaults are applied) but the user need not provide it, so it is
- * reported as not-required here, matching the legacy descriptor semantics where
- * `{ default }` implied `required: false`.
- */
-export function schemaIsRequired(schema: TSchema): boolean {
-	return !IsOptional(schema) && schemaDefault(schema) === undefined;
-}
-
-/** Derive the legacy normalized input descriptor for a single named field. */
-export function deriveInputField(name: string, schema: TSchema): WorkflowInputEntry {
-	const choices = schemaChoices(schema);
-	const def = schemaDefault(schema);
-	const description = schemaDescription(schema);
-	const entry: WorkflowInputEntry = {
-		name,
-		type: schemaFieldKind(schema),
-		required: schemaIsRequired(schema),
-	};
-	if (description !== undefined) entry.description = description;
-	if (def !== undefined) entry.default = def;
-	if (choices !== undefined) entry.choices = choices;
-	return entry;
-}
-
-/** Derive descriptors for an entire declared input map (preserving order). */
-export function deriveInputFields(schema: Readonly<Record<string, TSchema>>): WorkflowInputEntry[] {
-	return Object.entries(schema).map(([name, s]) => deriveInputField(name, s));
-}

package/dist/builtin/workflows/src/shared/serializable.ts

@@ -1,118 +0,0 @@
-import { Refine, type TSchema, Type } from "typebox";
-
-/**
- * A JSON-serializable object must be a *plain* object (or array, handled
- * separately) — class instances such as `Date`, `Map`, or `RegExp` structurally
- * look like empty records to the schema checker but are not JSON round-trippable,
- * so they are rejected here.
- */
-function isPlainObjectValue(value: unknown): boolean {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) return true;
-	const proto = Object.getPrototypeOf(value);
-	return proto === Object.prototype || proto === null;
-}
-
-import { Value } from "typebox/value";
-import type { WorkflowOutputValues, WorkflowSerializableValue } from "./types.js";
-
-export const WORKFLOW_SERIALIZABLE_DESCRIPTION =
-	"JSON-serializable (string, finite number, boolean, null, array, or object)";
-
-/**
- * Recursive TypeBox schema describing a JSON-serializable value: string, finite
- * number, boolean, null, array of serializable values, or an object whose
- * values are serializable. `Type.Number` already rejects NaN/Infinity in
- * TypeBox's value checker, matching the previous `z.number().finite()`.
- */
-export const workflowSerializableValueSchema: TSchema = Type.Cyclic(
-	{
-		Serializable: Type.Union([
-			Type.String(),
-			Type.Number(),
-			Type.Boolean(),
-			Type.Null(),
-			Type.Array(Type.Ref("Serializable")),
-			Refine(
-				Type.Record(Type.String(), Type.Ref("Serializable")),
-				isPlainObjectValue,
-				() => "must be a plain JSON object",
-			),
-		]),
-	},
-	"Serializable",
-);
-
-export const workflowSerializableObjectSchema: TSchema = Type.Record(Type.String(), workflowSerializableValueSchema);
-
-export function workflowSerializableTypeName(value: unknown): string {
-	if (value === null) return "null";
-	if (Array.isArray(value)) return "array";
-	if (typeof value === "number" && Number.isNaN(value)) return "NaN";
-	if (typeof value === "number" && !Number.isFinite(value)) return String(value);
-	return typeof value;
-}
-
-/** Convert a TypeBox `instancePath` ("/a/0/b") to the legacy "a[0].b" form. */
-function formatInstancePath(instancePath: string): string {
-	if (!instancePath) return "";
-	const segments = instancePath.split("/").filter((s) => s.length > 0);
-	return segments
-		.map((segment) =>
-			/^\d+$/.test(segment)
-				? `[${segment}]`
-				: /^[A-Za-z_$][\w$]*$/.test(segment)
-					? `.${segment}`
-					: `[${JSON.stringify(segment)}]`,
-		)
-		.join("")
-		.replace(/^\./, "");
-}
-
-/** Resolve the value located at a TypeBox instance path within `root`. */
-function valueAtInstancePath(root: unknown, instancePath: string): unknown {
-	if (!instancePath) return root;
-	let current: unknown = root;
-	for (const segment of instancePath.split("/").filter((s) => s.length > 0)) {
-		if (current === null || typeof current !== "object") return current;
-		current = (current as Record<string, unknown>)[segment];
-	}
-	return current;
-}
-
-function firstError(schema: TSchema, value: unknown): { instancePath: string } | undefined {
-	for (const error of Value.Errors(schema, value)) {
-		return { instancePath: error.instancePath };
-	}
-	return undefined;
-}
-
-export function workflowSerializableValidationError(value: unknown, label: string): string | undefined {
-	if (Value.Check(workflowSerializableValueSchema, value)) return undefined;
-	const issue = firstError(workflowSerializableValueSchema, value);
-	const issuePath = issue === undefined ? "" : formatInstancePath(issue.instancePath);
-	const location = issuePath.length > 0 ? ` at ${issuePath}` : "";
-	const offending = issue === undefined ? value : valueAtInstancePath(value, issue.instancePath);
-	return `${label}${location} must be ${WORKFLOW_SERIALIZABLE_DESCRIPTION}, got ${workflowSerializableTypeName(offending)}`;
-}
-
-export function workflowSerializableObjectValidationError(value: unknown, label: string): string | undefined {
-	if (Value.Check(workflowSerializableObjectSchema, value)) return undefined;
-	const issue = firstError(workflowSerializableObjectSchema, value);
-	const issuePath = issue === undefined ? "" : formatInstancePath(issue.instancePath);
-	const location = issuePath.length > 0 ? ` at ${issuePath}` : "";
-	const offending = issue === undefined ? value : valueAtInstancePath(value, issue.instancePath);
-	return `${label}${location} must be a ${WORKFLOW_SERIALIZABLE_DESCRIPTION} object, got ${workflowSerializableTypeName(offending)}`;
-}
-
-export function assertWorkflowSerializableValue(
-	value: unknown,
-	label: string,
-): asserts value is WorkflowSerializableValue {
-	const error = workflowSerializableValidationError(value, label);
-	if (error !== undefined) throw new Error(`atomic-workflows: ${error}`);
-}
-
-export function assertWorkflowSerializableObject(value: unknown, label: string): asserts value is WorkflowOutputValues {
-	const error = workflowSerializableObjectValidationError(value, label);
-	if (error !== undefined) throw new Error(`atomic-workflows: ${error}`);
-}

package/dist/builtin/workflows/src/shared/session-scoped-singleton.ts

@@ -1,98 +0,0 @@
-import { sessionScopedExtensionState } from "@bastani/atomic";
-
-/**
- * Shared across duplicate copies of this module after a host scope is adopted.
- * Windows' resolver can evaluate the same singleton file twice: one copy
- * registers, the other adopts. A module-local `instance` then splits them.
- *
- * Construction records this copy's local in the process bag if the key is new,
- * but `current()` / `facade` stay module-local until `adopt`. That keeps
- * no-scope evaluations isolated. The first `adopt` claims the recorded local
- * (the first constructor's populated object) into the host scope.
- */
-const SHARED_STATES_KEY = Symbol.for("atomic-workflows/session-scoped-singleton-pre-adoption@1");
-
-interface SharedSingletonState<T extends object> {
-	local: T;
-	instance: T | undefined;
-	localClaimed: boolean;
-}
-
-interface ProcessSingletonStates {
-	readonly version: 1;
-	readonly byKey: Map<string, SharedSingletonState<object>>;
-}
-
-function processBag(): Record<symbol, ProcessSingletonStates | undefined> {
-	return globalThis as typeof globalThis & Record<symbol, ProcessSingletonStates | undefined>;
-}
-
-function recordLocal<T extends object>(key: string, local: T): SharedSingletonState<T> {
-	const bag = processBag();
-	let states = bag[SHARED_STATES_KEY];
-	if (states === undefined || states.version !== 1) {
-		states = { version: 1, byKey: new Map() };
-		bag[SHARED_STATES_KEY] = states;
-	}
-	const existing = states.byKey.get(key) as SharedSingletonState<T> | undefined;
-	if (existing !== undefined) return existing;
-	const created: SharedSingletonState<T> = { local, instance: undefined, localClaimed: false };
-	states.byKey.set(key, created as SharedSingletonState<object>);
-	return created;
-}
-
-/** Drop every shared slot so unit tests stay isolated. */
-export function resetSessionScopedSingletonPreAdoptionForTests(): void {
-	delete processBag()[SHARED_STATES_KEY];
-}
-
-/**
- * Stable facade over a run-scoped singleton that can re-bind to host
- * session-scoped state after `/reload` re-evaluates the module graph.
- *
- * Local state seeds at most one unseen scope; later unseen scopes start fresh.
- * After the first adopt, every module copy for the same key reads one instance.
- */
-export interface SessionScopedSingleton<T extends object> {
-	readonly facade: T;
-	readonly adopt: (scope: object) => T;
-	readonly current: () => T;
-}
-
-export function createSessionScopedSingleton<T extends object>(
-	key: string,
-	createLocal: () => T,
-): SessionScopedSingleton<T> {
-	const local = createLocal();
-	const shared = recordLocal(key, local);
-	let instance = local;
-
-	const live = (): T => shared.instance ?? instance;
-
-	const current = (): T => live();
-
-	const adopt = (scope: object): T => {
-		shared.instance = sessionScopedExtensionState(scope, key, () => {
-			if (shared.localClaimed) return createLocal();
-			shared.localClaimed = true;
-			return shared.local;
-		});
-		instance = shared.instance;
-		return shared.instance;
-	};
-
-	const facade = new Proxy(local, {
-		get(_target, prop) {
-			const value = Reflect.get(live(), prop, live());
-			if (typeof value === "function") {
-				return value.bind(live());
-			}
-			return value;
-		},
-		has(_target, prop) {
-			return Reflect.has(live(), prop);
-		},
-	});
-
-	return { facade, adopt, current };
-}

package/dist/builtin/workflows/src/shared/session-transcript.ts

@@ -1,79 +0,0 @@
-/**
- * Shared retained-session transcript validation.
- *
- * A stage snapshot's `sessionFile` is only reopenable as a post-mortem chat
- * when the referenced path is an existing, readable, regular file whose JSONL
- * contents parse into a genuine Atomic session with at least one usable
- * context-bearing message. This guards the completed-workflow catalog and the
- * post-mortem stage-chat resolver against blank / missing / truncated
- * transcripts, and prevents `SessionManager.open()` from turning a missing path
- * into an empty session.
- *
- * cross-ref:
- *   - src/durable/completed-catalog.ts (catalog eligibility)
- *   - src/runs/foreground/postmortem-stage-chat.ts (revival eligibility)
- */
-import { readFileSync, statSync } from "node:fs";
-
-interface SessionTranscriptEntry {
-	readonly type?: string;
-	readonly id?: string;
-	readonly timestamp?: string;
-	readonly message?: {
-		readonly role?: string;
-		readonly content?: string | object;
-	};
-}
-
-/**
- * True when `path` points at a readable regular file containing a parseable
- * Atomic session header plus at least one usable context message.
- */
-export function isReopenableSessionTranscript(path: string): boolean {
-	try {
-		const stats = statSync(path);
-		if (!stats.isFile() || stats.size === 0) return false;
-		const lines = readFileSync(path, "utf8")
-			.split("\n")
-			.filter((line) => line.trim().length > 0);
-		if (lines.length < 2) return false;
-		const entries: SessionTranscriptEntry[] = [];
-		for (const line of lines) {
-			const parsed = JSON.parse(line) as object;
-			if (typeof parsed !== "object" || parsed === null) return false;
-			entries.push(parsed as SessionTranscriptEntry);
-		}
-		const header = entries[0];
-		return header?.type === "session" && typeof header.id === "string" && entries.some(isUsableContextMessage);
-	} catch {
-		return false;
-	}
-}
-
-function isUsableContextMessage(entry: SessionTranscriptEntry): boolean {
-	return (
-		entry.type === "message" &&
-		typeof entry.id === "string" &&
-		typeof entry.timestamp === "string" &&
-		typeof entry.message?.role === "string" &&
-		hasUsableMessageContent(entry.message.content)
-	);
-}
-
-function hasUsableMessageContent(content: string | object | undefined): boolean {
-	if (typeof content === "string") return content.trim().length > 0;
-	return Array.isArray(content) && content.some(hasUsableContentBlock);
-}
-
-function hasUsableContentBlock(block: object): boolean {
-	if (typeof block !== "object" || block === null) return false;
-	const contentBlock = block as {
-		readonly text?: string;
-		readonly thinking?: string;
-		readonly data?: string;
-		readonly name?: string;
-	};
-	return [contentBlock.text, contentBlock.thinking, contentBlock.data, contentBlock.name].some(
-		(value) => typeof value === "string" && value.trim().length > 0,
-	);
-}