substrate-ai 0.2.28 → 0.2.30

package/dist/config-migrator-DSi8KhQC.js

@@ -0,0 +1,244 @@
+import { readFileSync, writeFileSync } from "fs";
+import { z } from "zod";
+
+//#region src/modules/config/config-schema.ts
+/** Subscription routing modes */
+const SubscriptionRoutingSchema = z.enum([
+	"auto",
+	"subscription",
+	"api",
+	"disabled"
+]);
+/** Rate limit configuration for a provider */
+const RateLimitSchema = z.object({
+	tokens: z.number().int().positive(),
+	window_seconds: z.number().int().positive()
+}).strict();
+/** Per-provider configuration */
+const ProviderConfigSchema = z.object({
+	enabled: z.boolean(),
+	cli_path: z.string().optional(),
+	subscription_routing: SubscriptionRoutingSchema,
+	max_concurrent: z.number().int().min(1).max(32),
+	rate_limit: RateLimitSchema.optional(),
+	api_key_env: z.string().optional(),
+	api_billing: z.boolean()
+}).strict();
+/** Map of all known providers */
+const ProvidersSchema = z.object({
+	claude: ProviderConfigSchema.optional(),
+	codex: ProviderConfigSchema.optional(),
+	gemini: ProviderConfigSchema.optional()
+}).strict();
+const LogLevelSchema = z.enum([
+	"trace",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fatal"
+]);
+const GlobalSettingsSchema = z.object({
+	log_level: LogLevelSchema,
+	max_concurrent_tasks: z.number().int().min(1).max(64),
+	budget_cap_tokens: z.number().int().min(0),
+	budget_cap_usd: z.number().min(0),
+	workspace_dir: z.string().optional(),
+	update_check: z.boolean().optional()
+}).strict();
+const CostTrackerConfigSchema = z.object({
+	enabled: z.boolean(),
+	token_rates_provider: z.enum(["builtin", "custom"]),
+	track_planning_costs: z.boolean(),
+	savings_reporting: z.boolean()
+}).strict();
+const BudgetConfigSchema = z.object({
+	default_task_budget_usd: z.number().min(0),
+	default_session_budget_usd: z.number().min(0),
+	planning_costs_count_against_budget: z.boolean(),
+	warning_threshold_percent: z.number().min(0).max(100)
+}).strict();
+const RoutingRuleSchema = z.object({
+	task_type: z.string(),
+	preferred_provider: z.string(),
+	fallback_providers: z.array(z.string())
+}).strict();
+const RoutingPolicySchema = z.object({
+	default_provider: z.string(),
+	rules: z.array(RoutingRuleSchema)
+}).strict();
+/**
+* Per-workflow token ceiling overrides.
+* Keys match the workflow type names used in prompts and events.
+* Values must be positive integers.
+*/
+const TokenCeilingsSchema = z.object({
+	"create-story": z.number().int().positive("create-story token ceiling must be a positive integer").optional(),
+	"dev-story": z.number().int().positive("dev-story token ceiling must be a positive integer").optional(),
+	"code-review": z.number().int().positive("code-review token ceiling must be a positive integer").optional(),
+	"test-plan": z.number().int().positive("test-plan token ceiling must be a positive integer").optional(),
+	"test-expansion": z.number().int().positive("test-expansion token ceiling must be a positive integer").optional()
+});
+/** Current supported config format version */
+const CURRENT_CONFIG_FORMAT_VERSION = "1";
+/** Current supported task graph version */
+const CURRENT_TASK_GRAPH_VERSION = "1";
+/** All config format versions this toolkit can read and validate */
+const SUPPORTED_CONFIG_FORMAT_VERSIONS = ["1"];
+/** All task graph format versions this toolkit can read and validate */
+const SUPPORTED_TASK_GRAPH_VERSIONS = ["1"];
+const SubstrateConfigSchema = z.object({
+	config_format_version: z.enum(["1"]),
+	task_graph_version: z.enum(["1"]).optional(),
+	global: GlobalSettingsSchema,
+	providers: ProvidersSchema,
+	cost_tracker: CostTrackerConfigSchema.optional(),
+	budget: BudgetConfigSchema.optional(),
+	token_ceilings: TokenCeilingsSchema.optional()
+}).strict();
+const PartialProviderConfigSchema = ProviderConfigSchema.partial();
+const PartialGlobalSettingsSchema = GlobalSettingsSchema.partial();
+const PartialSubstrateConfigSchema = z.object({
+	config_format_version: z.enum(["1"]).optional(),
+	task_graph_version: z.enum(["1"]).optional(),
+	global: PartialGlobalSettingsSchema.optional(),
+	providers: z.object({
+		claude: PartialProviderConfigSchema.optional(),
+		codex: PartialProviderConfigSchema.optional(),
+		gemini: PartialProviderConfigSchema.optional()
+	}).partial().optional(),
+	cost_tracker: CostTrackerConfigSchema.partial().optional(),
+	budget: BudgetConfigSchema.partial().optional(),
+	token_ceilings: TokenCeilingsSchema.optional()
+}).strict();
+
+//#endregion
+//#region src/modules/config/config-migrator.ts
+/**
+* ConfigMigrator manages a registry of migration functions and applies them
+* sequentially to upgrade config documents from one format version to another.
+*/
+var ConfigMigrator = class {
+	migrations = new Map();
+	/**
+	* Register a migration function for the given version key.
+	*
+	* @param key - Migration key in format "N->M" (e.g. "1->2")
+	* @param fn - Migration function that receives the raw config and returns the migrated config
+	*/
+	register(key, fn) {
+		this.migrations.set(key, fn);
+	}
+	/**
+	* Check whether a sequential migration path exists from fromVersion to toVersion.
+	*
+	* @param fromVersion - Starting version string
+	* @param toVersion - Target version string
+	* @returns true if every step in the path is registered
+	*/
+	canMigrate(fromVersion, toVersion) {
+		if (fromVersion === toVersion) return true;
+		const from = parseInt(fromVersion, 10);
+		const to = parseInt(toVersion, 10);
+		if (isNaN(from) || isNaN(to) || from >= to) return false;
+		for (let v = from; v < to; v++) {
+			const key = `${String(v)}->${String(v + 1)}`;
+			if (!this.migrations.has(key)) return false;
+		}
+		return true;
+	}
+	/**
+	* Apply sequential migrations from fromVersion to toVersion.
+	*
+	* If fromVersion === toVersion, returns a no-op success result.
+	* If any intermediate migration is missing, returns success:false.
+	*
+	* When filePath is provided and migration is needed, a backup is written to
+	* `${filePath}.bak.v${fromVersion}` before any transformations are applied.
+	*
+	* @param config - Raw config object to migrate
+	* @param fromVersion - Starting format version string
+	* @param toVersion - Target format version string
+	* @param filePath - Optional path to the source config file for backup creation
+	* @returns Object containing the (possibly migrated) config and a MigrationResult
+	*/
+	migrate(config, fromVersion, toVersion, filePath) {
+		if (fromVersion === toVersion) return {
+			config,
+			result: {
+				success: true,
+				fromVersion,
+				toVersion,
+				migratedKeys: [],
+				manualStepsRequired: [],
+				backupPath: null
+			}
+		};
+		const from = parseInt(fromVersion, 10);
+		const to = parseInt(toVersion, 10);
+		if (isNaN(from) || isNaN(to) || from >= to) return {
+			config,
+			result: {
+				success: false,
+				fromVersion,
+				toVersion,
+				migratedKeys: [],
+				manualStepsRequired: [`Cannot migrate from version "${fromVersion}" to "${toVersion}": invalid version range.`],
+				backupPath: null
+			}
+		};
+		for (let v = from; v < to; v++) {
+			const key = `${String(v)}->${String(v + 1)}`;
+			if (!this.migrations.has(key)) return {
+				config,
+				result: {
+					success: false,
+					fromVersion,
+					toVersion,
+					migratedKeys: [],
+					manualStepsRequired: [`Missing migration step: "${key}". Cannot automatically migrate from version "${fromVersion}" to "${toVersion}". Please upgrade the toolkit: npm install -g substrate@latest`],
+					backupPath: null
+				}
+			};
+		}
+		let backupPath = null;
+		if (filePath !== void 0) {
+			backupPath = `${filePath}.bak.v${fromVersion}`;
+			const originalContent = readFileSync(filePath, "utf-8");
+			writeFileSync(backupPath, originalContent, "utf-8");
+		}
+		let current = config;
+		const migratedKeys = [];
+		for (let v = from; v < to; v++) {
+			const key = `${String(v)}->${String(v + 1)}`;
+			const fn = this.migrations.get(key);
+			const before = JSON.stringify(current);
+			current = fn(current);
+			const after = JSON.stringify(current);
+			if (current !== null && typeof current === "object" && !Array.isArray(current)) {
+				const beforeObj = JSON.parse(before);
+				const afterObj = JSON.parse(after);
+				for (const k of Object.keys(afterObj)) if (JSON.stringify(afterObj[k]) !== JSON.stringify(beforeObj[k])) {
+					if (!migratedKeys.includes(k)) migratedKeys.push(k);
+				}
+			}
+		}
+		return {
+			config: current,
+			result: {
+				success: true,
+				fromVersion,
+				toVersion,
+				migratedKeys,
+				manualStepsRequired: [],
+				backupPath
+			}
+		};
+	}
+};
+/** Singleton instance for use throughout the toolkit */
+const defaultConfigMigrator = new ConfigMigrator();
+
+//#endregion
+export { CURRENT_CONFIG_FORMAT_VERSION, CURRENT_TASK_GRAPH_VERSION, PartialSubstrateConfigSchema, SUPPORTED_CONFIG_FORMAT_VERSIONS, SUPPORTED_TASK_GRAPH_VERSIONS, SubstrateConfigSchema, defaultConfigMigrator };
+//# sourceMappingURL=config-migrator-DSi8KhQC.js.map

package/dist/{experimenter-bc40oi8p.js → experimenter-f_Y1rreV.js}

@@ -500,4 +500,4 @@ function createExperimenter(config, deps) {
 
 //#endregion
 export { createExperimenter };
-//# sourceMappingURL=experimenter-bc40oi8p.js.map
+//# sourceMappingURL=experimenter-f_Y1rreV.js.map

package/dist/{helpers-DljGJnFF.js → helpers-RL22dYtn.js}

@@ -2,6 +2,115 @@ import * as readline from "node:readline";
 import { EventEmitter } from "node:events";
 import { randomUUID } from "crypto";
 
+//#region src/core/errors.ts
+/**
+* Error definitions for Substrate
+* Provides structured error hierarchy for all toolkit operations
+*/
+/** Base error class for all Substrate errors */
+var AdtError = class AdtError extends Error {
+	code;
+	context;
+	constructor(message, code, context = {}) {
+		super(message);
+		this.name = "AdtError";
+		this.code = code;
+		this.context = context;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, AdtError);
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			code: this.code,
+			context: this.context,
+			stack: this.stack
+		};
+	}
+};
+/** Error thrown when task configuration is invalid */
+var TaskConfigError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "TASK_CONFIG_ERROR", context);
+		this.name = "TaskConfigError";
+	}
+};
+/** Error thrown when a worker/agent operation fails */
+var WorkerError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "WORKER_ERROR", context);
+		this.name = "WorkerError";
+	}
+};
+/** Error thrown when a worker/agent cannot be found */
+var WorkerNotFoundError = class extends AdtError {
+	constructor(agentId) {
+		super(`Worker agent not found: ${agentId}`, "WORKER_NOT_FOUND", { agentId });
+		this.name = "WorkerNotFoundError";
+	}
+};
+/** Error thrown when a task graph is invalid */
+var TaskGraphError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "TASK_GRAPH_ERROR", context);
+		this.name = "TaskGraphError";
+	}
+};
+/** Error thrown when a task graph has cycles (deadlock) */
+var TaskGraphCycleError = class extends TaskGraphError {
+	constructor(cycle) {
+		super(`Circular dependency detected in task graph: ${cycle.join(" -> ")}`, { cycle });
+		this.name = "TaskGraphCycleError";
+	}
+};
+/** Error thrown when a budget limit is exceeded */
+var BudgetExceededError = class extends AdtError {
+	constructor(limit, current, context = {}) {
+		super(`Budget cap exceeded: current=${String(current)}, limit=${String(limit)}`, "BUDGET_EXCEEDED", {
+			limit,
+			current,
+			...context
+		});
+		this.name = "BudgetExceededError";
+	}
+};
+/** Error thrown when git operations fail */
+var GitError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "GIT_ERROR", context);
+		this.name = "GitError";
+	}
+};
+/** Error thrown when configuration is invalid or missing */
+var ConfigError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "CONFIG_ERROR", context);
+		this.name = "ConfigError";
+	}
+};
+/** Error thrown when state recovery fails */
+var RecoveryError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "RECOVERY_ERROR", context);
+		this.name = "RecoveryError";
+	}
+};
+/** Error thrown when a config file uses an incompatible format version */
+var ConfigIncompatibleFormatError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "CONFIG_INCOMPATIBLE_FORMAT", context);
+		this.name = "ConfigIncompatibleFormatError";
+	}
+};
+/** Error thrown when a task graph file uses an incompatible format version */
+var TaskGraphIncompatibleFormatError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "TASK_GRAPH_INCOMPATIBLE_FORMAT", context);
+		this.name = "TaskGraphIncompatibleFormatError";
+	}
+};
+
+//#endregion
 //#region src/tui/ansi.ts
 /**
 * ANSI escape code helpers for TUI rendering.
@@ -807,5 +916,5 @@ async function withRetry(fn, maxRetries = 3, baseDelayMs = 100) {
 }
 
 //#endregion
-export { assertDefined, createEventBus, createTuiApp, deepClone, formatDuration, generateId, isPlainObject, isTuiCapable, printNonTtyWarning, sleep, withRetry };
-//# sourceMappingURL=helpers-DljGJnFF.js.map
+export { AdtError, BudgetExceededError, ConfigError, ConfigIncompatibleFormatError, GitError, RecoveryError, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, WorkerError, WorkerNotFoundError, assertDefined, createEventBus, createTuiApp, deepClone, formatDuration, generateId, isPlainObject, isTuiCapable, printNonTtyWarning, sleep, withRetry };
+//# sourceMappingURL=helpers-RL22dYtn.js.map

package/dist/index.js

@@ -1,6 +1,6 @@
 import { childLogger, createLogger, logger } from "./logger-D2fS2ccL.js";
-import { AdapterRegistry, AdtError, BudgetExceededError, ClaudeCodeAdapter, CodexCLIAdapter, ConfigError, ConfigIncompatibleFormatError, GeminiCLIAdapter, GitError, RecoveryError, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, WorkerError, WorkerNotFoundError } from "./errors-CswS7Mzg.js";
-import { assertDefined, createEventBus, createTuiApp, deepClone, formatDuration, generateId, isPlainObject, isTuiCapable, printNonTtyWarning, sleep, withRetry } from "./helpers-DljGJnFF.js";
+import { AdapterRegistry, ClaudeCodeAdapter, CodexCLIAdapter, GeminiCLIAdapter } from "./adapter-registry-PsWhP_1Q.js";
+import { AdtError, BudgetExceededError, ConfigError, ConfigIncompatibleFormatError, GitError, RecoveryError, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, WorkerError, WorkerNotFoundError, assertDefined, createEventBus, createTuiApp, deepClone, formatDuration, generateId, isPlainObject, isTuiCapable, printNonTtyWarning, sleep, withRetry } from "./helpers-RL22dYtn.js";
 
 //#region src/core/di.ts
 /**