substrate-ai 0.1.0

package/dist/index.js

@@ -0,0 +1,465 @@
+import { AdapterRegistry, AdtError, BudgetExceededError, ClaudeCodeAdapter, CodexCLIAdapter, ConfigError, ConfigIncompatibleFormatError, GeminiCLIAdapter, GitError, RecoveryError, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, WorkerError, WorkerNotFoundError, childLogger, computeChangedKeys, createConfigWatcher, createDatabaseService, createEventBus, createGitWorktreeManager, createLogger, createMonitorAgent, createMonitorDatabase, createRoutingEngine, createTaskGraphEngine, createWorkerPoolManager, logger } from "./config-watcher-P5CR4cZ0.js";
+import "./config-schema-C9tTMcm1.js";
+import { join } from "node:path";
+import { randomUUID } from "crypto";
+
+//#region src/utils/helpers.ts
+/**
+* Sleep for a given number of milliseconds
+* @param ms - Milliseconds to sleep
+*/
+function sleep(ms) {
+	return new Promise((resolve$1) => setTimeout(resolve$1, ms));
+}
+/**
+* Assert that a value is defined (not null or undefined)
+* @param value - Value to check
+* @param message - Error message if undefined
+*/
+function assertDefined(value, message) {
+	if (value === null || value === void 0) throw new Error(message);
+}
+/**
+* Format a duration in milliseconds to a human-readable string
+* @param ms - Duration in milliseconds
+*/
+function formatDuration(ms) {
+	if (ms < 1e3) return `${String(ms)}ms`;
+	if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+	if (ms < 36e5) {
+		const minutes$1 = Math.floor(ms / 6e4);
+		const seconds = Math.floor(ms % 6e4 / 1e3);
+		return `${String(minutes$1)}m ${String(seconds)}s`;
+	}
+	const hours = Math.floor(ms / 36e5);
+	const minutes = Math.floor(ms % 36e5 / 6e4);
+	return `${String(hours)}h ${String(minutes)}m`;
+}
+/**
+* Generate a unique identifier using crypto.randomUUID()
+* @param prefix - Optional prefix for the ID
+*/
+function generateId(prefix = "") {
+	const uuid = randomUUID();
+	return prefix ? `${prefix}-${uuid}` : uuid;
+}
+/**
+* Deep clone an object using structuredClone.
+* Supports most built-in types (Date, Map, Set, ArrayBuffer, etc.)
+* but does NOT support functions, DOM nodes, or symbols as keys.
+* @param obj - Object to clone
+*/
+function deepClone(obj) {
+	return structuredClone(obj);
+}
+/**
+* Check if a value is a plain object (not an array, Date, or other special object)
+* @param value - Value to check
+*/
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* Retry an async operation with exponential backoff
+* @param fn - Async function to retry
+* @param maxRetries - Maximum number of retries
+* @param baseDelayMs - Base delay in milliseconds (doubles each retry)
+*/
+async function withRetry(fn, maxRetries = 3, baseDelayMs = 100) {
+	let lastError;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		return await fn();
+	} catch (error) {
+		lastError = error instanceof Error ? error : new Error(String(error));
+		if (attempt < maxRetries) await sleep(baseDelayMs * Math.pow(2, attempt));
+	}
+	throw lastError ?? new Error("Operation failed after retries");
+}
+
+//#endregion
+//#region src/core/di.ts
+/**
+* Simple service registry — stores named service instances for DI resolution.
+*
+* Services are registered by name and can be retrieved by name or iterated
+* in registration order for lifecycle management.
+*
+* @example
+* const registry = new ServiceRegistry()
+* registry.register('taskGraph', taskGraphEngine)
+* registry.register('workerManager', workerManager)
+*
+* // Initialize all services
+* await registry.initializeAll()
+*
+* // Shutdown all services in reverse order
+* await registry.shutdownAll()
+*/
+var ServiceRegistry = class {
+	_services = new Map();
+	_order = [];
+	/**
+	* Register a named service. Registration order is preserved for lifecycle calls.
+	* @throws {Error} if a service with the same name is already registered.
+	*/
+	register(name, service) {
+		if (this._services.has(name)) throw new Error(`Service "${name}" is already registered`);
+		this._services.set(name, service);
+		this._order.push(name);
+	}
+	/**
+	* Retrieve a registered service by name.
+	* @throws {Error} if no service with the given name is registered.
+	*/
+	get(name) {
+		const service = this._services.get(name);
+		if (service === void 0) throw new Error(`Service "${name}" is not registered`);
+		return service;
+	}
+	/**
+	* Returns true if a service with the given name is registered.
+	*/
+	has(name) {
+		return this._services.has(name);
+	}
+	/**
+	* Initialize all registered services in registration order.
+	* Fails fast on the first error — later services may depend on
+	* already-initialized ones, so continuing after a failure is unsafe.
+	* @throws the first initialization error encountered.
+	*/
+	async initializeAll() {
+		for (const name of this._order) {
+			const service = this._services.get(name);
+			if (service !== void 0) await service.initialize();
+		}
+	}
+	/**
+	* Shut down all registered services in reverse registration order.
+	* Errors are collected and re-thrown as an AggregateError after all services
+	* have had a chance to shut down.
+	*/
+	async shutdownAll() {
+		const errors = [];
+		const reversed = [...this._order].reverse();
+		for (const name of reversed) {
+			const service = this._services.get(name);
+			if (service !== void 0) try {
+				await service.shutdown();
+			} catch (err) {
+				errors.push(err instanceof Error ? err : new Error(String(err)));
+			}
+		}
+		if (errors.length > 0) throw new AggregateError(errors, `Shutdown errors in ${errors.length} service(s)`);
+	}
+	/** Return names of all registered services in registration order */
+	get serviceNames() {
+		return [...this._order];
+	}
+};
+
+//#endregion
+//#region src/modules/budget/budget-tracker.ts
+const logger$3 = createLogger("budget");
+var BudgetTrackerImpl = class {
+	_eventBus;
+	constructor(eventBus) {
+		this._eventBus = eventBus;
+	}
+	async initialize() {
+		logger$3.info("BudgetTracker.initialize() — stub");
+		this._eventBus.on("budget:warning", ({ taskId, currentSpend, limit }) => {
+			logger$3.warn({
+				taskId,
+				currentSpend,
+				limit
+			}, "budget:warning");
+		});
+		this._eventBus.on("budget:exceeded", ({ taskId, spend, limit }) => {
+			logger$3.error({
+				taskId,
+				spend,
+				limit
+			}, "budget:exceeded");
+		});
+		this._eventBus.on("task:complete", ({ taskId, result }) => {
+			logger$3.debug({
+				taskId,
+				costUsd: result.costUsd
+			}, "task:complete — accumulate cost");
+		});
+		this._eventBus.on("task:progress", ({ taskId, tokensUsed }) => {
+			logger$3.debug({
+				taskId,
+				tokensUsed
+			}, "task:progress — update token usage");
+		});
+	}
+	async shutdown() {
+		logger$3.info("BudgetTracker.shutdown() — stub");
+	}
+};
+function createBudgetTracker(options) {
+	return new BudgetTrackerImpl(options.eventBus);
+}
+
+//#endregion
+//#region src/modules/git/git-manager.ts
+const logger$2 = createLogger("git");
+var GitManagerImpl = class {
+	_eventBus;
+	repoRoot;
+	constructor(eventBus, repoRoot) {
+		this._eventBus = eventBus;
+		this.repoRoot = repoRoot;
+	}
+	async initialize() {
+		logger$2.info({ repoRoot: this.repoRoot }, "GitManager.initialize() — stub");
+		this._eventBus.on("worktree:created", ({ taskId, worktreePath, branchName }) => {
+			logger$2.debug({
+				taskId,
+				worktreePath,
+				branchName
+			}, "worktree:created");
+		});
+		this._eventBus.on("worktree:merged", ({ taskId, branch }) => {
+			logger$2.debug({
+				taskId,
+				branch
+			}, "worktree:merged");
+		});
+		this._eventBus.on("worktree:conflict", ({ taskId, conflictingFiles }) => {
+			logger$2.warn({
+				taskId,
+				conflictingFiles
+			}, "worktree:conflict");
+		});
+		this._eventBus.on("worktree:removed", ({ taskId, branchName }) => {
+			logger$2.debug({
+				taskId,
+				branchName
+			}, "worktree:removed");
+		});
+	}
+	async shutdown() {
+		logger$2.info("GitManager.shutdown() — stub");
+	}
+};
+function createGitManager(options) {
+	return new GitManagerImpl(options.eventBus, options.repoRoot);
+}
+
+//#endregion
+//#region src/core/orchestrator-impl.ts
+const logger$1 = createLogger("orchestrator");
+/** Internal symbol used to expose lifecycle hooks to the factory only */
+const INTERNAL = Symbol("OrchestratorImpl.internal");
+var OrchestratorImpl = class {
+	eventBus;
+	_registry;
+	_ready = false;
+	_shutdown = false;
+	_shutdownHandlersRegistered = false;
+	_configWatcher = null;
+	constructor(eventBus, registry) {
+		this.eventBus = eventBus;
+		this._registry = registry;
+	}
+	get isReady() {
+		return this._ready;
+	}
+	async shutdown() {
+		if (this._shutdown) return;
+		this._shutdown = true;
+		logger$1.info("Orchestrator shutdown initiated");
+		this.eventBus.emit("orchestrator:shutdown", { reason: "shutdown() called" });
+		if (this._configWatcher !== null) {
+			this._configWatcher.stop();
+			this._configWatcher = null;
+		}
+		try {
+			await this._registry.shutdownAll();
+		} catch (err) {
+			logger$1.error({ err }, "Error during orchestrator shutdown");
+		}
+		logger$1.info("Orchestrator shutdown complete");
+	}
+	_markReady() {
+		this._ready = true;
+	}
+	_sigtermHandler = null;
+	_sigintHandler = null;
+	_registerShutdownHandlers() {
+		if (this._shutdownHandlersRegistered) return;
+		this._shutdownHandlersRegistered = true;
+		const makeHandler = (signal) => () => {
+			logger$1.info({ signal }, "Received signal — initiating graceful shutdown");
+			this.shutdown().then(() => {
+				process.exit(0);
+			}).catch((err) => {
+				logger$1.error({ err }, "Error during signal-triggered shutdown");
+				process.exit(1);
+			});
+		};
+		this._sigtermHandler = makeHandler("SIGTERM");
+		this._sigintHandler = makeHandler("SIGINT");
+		process.once("SIGTERM", this._sigtermHandler);
+		process.once("SIGINT", this._sigintHandler);
+	}
+	_removeShutdownHandlers() {
+		if (this._sigtermHandler !== null) {
+			process.removeListener("SIGTERM", this._sigtermHandler);
+			this._sigtermHandler = null;
+		}
+		if (this._sigintHandler !== null) {
+			process.removeListener("SIGINT", this._sigintHandler);
+			this._sigintHandler = null;
+		}
+	}
+	/**
+	* Internal accessor used exclusively by the createOrchestrator factory.
+	* Do not call outside of this module.
+	* @internal
+	*/
+	[INTERNAL]() {
+		return {
+			markReady: () => this._markReady(),
+			registerShutdownHandlers: () => this._registerShutdownHandlers(),
+			removeShutdownHandlers: () => this._removeShutdownHandlers(),
+			setConfigWatcher: (watcher) => {
+				this._configWatcher = watcher;
+			}
+		};
+	}
+};
+/**
+* Initialize the orchestrator with all modules wired via dependency injection.
+*
+* Steps performed:
+*  1. Create the TypedEventBus
+*  2. Create the SQLite database service
+*  3. Instantiate all modules (TaskGraphEngine, RoutingEngine, WorkerManager,
+*     BudgetTracker, GitManager) with constructor injection
+*  4. Register all modules in the ServiceRegistry
+*  5. Call initialize() on all services in registration order
+*  6. Register SIGTERM/SIGINT graceful shutdown handlers
+*  7. Emit orchestrator:ready
+*
+* @param config - Orchestrator configuration
+* @returns Initialized Orchestrator instance
+*/
+async function createOrchestrator(config) {
+	logger$1.info({ databasePath: config.databasePath }, "Initializing orchestrator");
+	const eventBus = createEventBus();
+	const databaseService = createDatabaseService(config.databasePath);
+	const taskGraphEngine = createTaskGraphEngine({
+		eventBus,
+		databaseService
+	});
+	const adapterRegistry = new AdapterRegistry();
+	const routingEngine = createRoutingEngine({
+		eventBus,
+		adapterRegistry
+	});
+	const budgetTracker = createBudgetTracker({ eventBus });
+	const gitManager = createGitManager({
+		eventBus,
+		repoRoot: config.projectRoot
+	});
+	const gitWorktreeManager = createGitWorktreeManager({
+		eventBus,
+		projectRoot: config.projectRoot,
+		db: databaseService
+	});
+	const workerPoolManager = createWorkerPoolManager({
+		eventBus,
+		adapterRegistry,
+		engine: taskGraphEngine,
+		db: databaseService,
+		gitWorktreeManager
+	});
+	const monitorDbPath = config.monitor?.databasePath ?? ":memory:";
+	const monitorDatabase = createMonitorDatabase(monitorDbPath);
+	const monitorAgent = createMonitorAgent({
+		eventBus,
+		monitorDb: monitorDatabase,
+		config: {
+			retentionDays: config.monitor?.retentionDays ?? 90,
+			customTaxonomy: config.monitor?.customTaxonomy,
+			use_recommendations: config.monitor?.use_recommendations ?? false,
+			recommendation_threshold_percentage: config.monitor?.recommendation_threshold_percentage,
+			min_sample_size: config.monitor?.min_sample_size,
+			recommendation_history_days: config.monitor?.recommendation_history_days
+		}
+	});
+	const registry = new ServiceRegistry();
+	registry.register("database", databaseService);
+	registry.register("taskGraph", taskGraphEngine);
+	registry.register("routingEngine", routingEngine);
+	registry.register("gitWorktreeManager", gitWorktreeManager);
+	registry.register("workerPoolManager", workerPoolManager);
+	registry.register("budgetTracker", budgetTracker);
+	registry.register("gitManager", gitManager);
+	registry.register("monitorAgent", monitorAgent);
+	const orchestrator = new OrchestratorImpl(eventBus, registry);
+	const internal = orchestrator[INTERNAL]();
+	try {
+		await registry.initializeAll();
+	} catch (err) {
+		logger$1.error({ err }, "Service initialization failed — cleaning up");
+		internal.removeShutdownHandlers();
+		try {
+			await registry.shutdownAll();
+		} catch (shutdownErr) {
+			logger$1.error({ err: shutdownErr }, "Error during cleanup after failed initialization");
+		}
+		throw err;
+	}
+	internal.registerShutdownHandlers();
+	const enableConfigHotReload = config.enableConfigHotReload ?? true;
+	if (enableConfigHotReload) {
+		const configFilePath = config.configPath ?? join(config.projectRoot, "substrate.config.yaml");
+		let currentConfig = null;
+		const configWatcher = createConfigWatcher({
+			configPath: configFilePath,
+			onReload: (newConfig) => {
+				const previousConfig = currentConfig;
+				if (previousConfig === null) {
+					currentConfig = newConfig;
+					return;
+				}
+				const changedKeys = computeChangedKeys(previousConfig, newConfig);
+				currentConfig = newConfig;
+				const n = changedKeys.length;
+				logger$1.info({
+					changedKeys,
+					configPath: configFilePath
+				}, `Config reloaded: ${n} setting(s) changed`);
+				eventBus.emit("config:reloaded", {
+					path: configFilePath,
+					previousConfig,
+					newConfig,
+					changedKeys
+				});
+			},
+			onError: (err) => {
+				logger$1.error({
+					err,
+					configPath: configFilePath
+				}, `Config reload failed: ${err.message}. Continuing with previous config.`);
+			}
+		});
+		configWatcher.start();
+		internal.setConfigWatcher(configWatcher);
+	}
+	internal.markReady();
+	eventBus.emit("orchestrator:ready", {});
+	logger$1.info("Orchestrator ready");
+	return orchestrator;
+}
+
+//#endregion
+export { AdapterRegistry, AdtError, BudgetExceededError, ClaudeCodeAdapter, CodexCLIAdapter, ConfigError, ConfigIncompatibleFormatError, GeminiCLIAdapter, GitError, RecoveryError, ServiceRegistry, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, WorkerError, WorkerNotFoundError, assertDefined, childLogger, createEventBus, createLogger, createOrchestrator, deepClone, formatDuration, generateId, isPlainObject, logger, sleep, withRetry };
+//# sourceMappingURL=index.js.map

package/dist/upgrade-0Q2TKgQ4.js

@@ -0,0 +1,5 @@
+import "./config-schema-C9tTMcm1.js";
+import "./version-manager-impl-DbHmed-I.js";
+import { isGlobalInstall, registerUpgradeCommand, runUpgradeCommand } from "./upgrade-BBPbOHol.js";
+
+export { isGlobalInstall, registerUpgradeCommand, runUpgradeCommand };

package/dist/upgrade-BBPbOHol.js

@@ -0,0 +1,126 @@
+import { createVersionManager } from "./version-manager-impl-DbHmed-I.js";
+import { execSync, spawn } from "child_process";
+import * as readline from "readline";
+
+//#region src/cli/commands/upgrade.ts
+/**
+* Detect whether substrate is installed globally.
+*/
+function isGlobalInstall() {
+	try {
+		execSync("npm list -g substrate --depth=0", { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function printVersionTable(currentVersion, latestVersion, isBreaking, changelog) {
+	console.log("\nSubstrate update available:");
+	console.log(`  Current version : v${currentVersion}`);
+	console.log(`  Latest version  : v${latestVersion}`);
+	console.log(`  Breaking changes: ${isBreaking ? "Yes (major version bump)" : "No"}`);
+	console.log(`  Changelog       : ${changelog}`);
+	console.log();
+}
+async function promptConfirm(question) {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	return new Promise((resolve) => {
+		rl.question(question, (answer) => {
+			rl.close();
+			resolve(answer.toLowerCase() === "y");
+		});
+	});
+}
+async function runNpmInstall(version, global, spawnFn = spawn) {
+	const args = global ? [
+		"install",
+		"-g",
+		`substrate@${version}`
+	] : ["install", `substrate@${version}`];
+	return new Promise((resolve, reject) => {
+		const child = spawnFn("npm", args, { stdio: "inherit" });
+		child.on("close", (code) => {
+			if (code === 0) resolve();
+			else reject(new Error(`npm install exited with code ${String(code)}`));
+		});
+		child.on("error", (err) => {
+			reject(new Error(`Failed to spawn npm: ${err.message}`));
+		});
+	});
+}
+/**
+* Execute the upgrade command logic.
+* Exported for testability.
+*/
+async function runUpgradeCommand(options) {
+	const versionManager = options.versionManager ?? createVersionManager();
+	const promptFn = options.promptFn ?? promptConfirm;
+	const spawnFn = options.spawnFn ?? spawn;
+	if (options.check) {
+		let result$1;
+		try {
+			result$1 = await versionManager.checkForUpdates(true);
+		} catch {
+			process.stderr.write("Warning: Could not reach npm registry to check for updates. Continuing anyway.\n");
+			return;
+		}
+		if (!result$1.updateAvailable) {
+			console.log(`substrate is up to date (v${result$1.currentVersion})`);
+			return;
+		}
+		printVersionTable(result$1.currentVersion, result$1.latestVersion, result$1.isBreaking, result$1.changelog);
+		return;
+	}
+	let result;
+	try {
+		result = await versionManager.checkForUpdates();
+	} catch {
+		process.stderr.write("Warning: Could not reach npm registry to check for updates. Continuing anyway.\n");
+		return;
+	}
+	if (!result.updateAvailable) {
+		console.log(`substrate is up to date (v${result.currentVersion})`);
+		return;
+	}
+	const preview = versionManager.getUpgradePreview(result.latestVersion);
+	printVersionTable(result.currentVersion, result.latestVersion, result.isBreaking, result.changelog);
+	if (preview.breakingChanges.length > 0) {
+		console.log("Breaking changes:");
+		for (const change of preview.breakingChanges) console.log(`  - ${change}`);
+		console.log();
+	}
+	if (preview.migrationSteps.length > 0) {
+		console.log("Migration steps:");
+		for (const step of preview.migrationSteps) console.log(`  - ${step}`);
+		console.log();
+	}
+	if (!options.yes) {
+		const confirmed = await promptFn(`Upgrade substrate from v${result.currentVersion} to v${result.latestVersion}? (y/N) `);
+		if (!confirmed) {
+			console.log("Upgrade aborted.");
+			return;
+		}
+	}
+	const global = isGlobalInstall();
+	console.log(`Running: npm install ${global ? "-g " : ""}substrate@${result.latestVersion}`);
+	try {
+		await runNpmInstall(result.latestVersion, global, spawnFn);
+		console.log(`\nSuccessfully upgraded to v${result.latestVersion}`);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		process.stderr.write(`Upgrade failed: ${message}\n`);
+		process.exitCode = 1;
+	}
+}
+function registerUpgradeCommand(program) {
+	program.command("upgrade").description("Check for updates and upgrade substrate to the latest version").option("--check", "Check for updates without upgrading").option("-y, --yes", "Skip confirmation prompt (non-interactive upgrade)").action(async (options) => {
+		await runUpgradeCommand(options);
+	});
+}
+
+//#endregion
+export { isGlobalInstall, registerUpgradeCommand, runUpgradeCommand };
+//# sourceMappingURL=upgrade-BBPbOHol.js.map

package/dist/version-manager-impl-Bij9-k0W.js

@@ -0,0 +1,4 @@
+import "./config-schema-C9tTMcm1.js";
+import { VersionManagerImpl, createVersionManager } from "./version-manager-impl-DbHmed-I.js";
+
+export { createVersionManager };