substrate-ai 0.1.0

package/dist/version-manager-impl-DbHmed-I.js

@@ -0,0 +1,485 @@
+import { SUPPORTED_CONFIG_FORMAT_VERSIONS, SUPPORTED_TASK_GRAPH_VERSIONS } from "./config-schema-C9tTMcm1.js";
+import { createRequire } from "module";
+import path, { dirname } from "path";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import os from "os";
+import https from "https";
+import * as semver from "semver";
+
+//#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
+//#region src/modules/version-manager/update-checker.ts
+/**
+* Thrown when an update check fails due to network error, timeout, or bad response.
+*/
+var UpdateCheckError = class extends Error {
+	name = "UpdateCheckError";
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/**
+* Queries the npm registry to determine the latest published version of a package.
+*/
+var UpdateChecker = class {
+	timeoutMs;
+	constructor(timeoutMs = 5e3) {
+		this.timeoutMs = timeoutMs;
+	}
+	/**
+	* Fetch the latest published version of a package from the npm registry.
+	*
+	* @param packageName - npm package name (e.g. 'substrate')
+	* @returns The latest version string (semver)
+	* @throws {UpdateCheckError} on timeout, network error, non-200 HTTP status, or parse failure
+	*/
+	fetchLatestVersion(packageName) {
+		return new Promise((resolve$1, reject) => {
+			const url = `https://registry.npmjs.org/${packageName}/latest`;
+			let settled = false;
+			const safeReject = (err) => {
+				if (!settled) {
+					settled = true;
+					clearTimeout(timer);
+					reject(err);
+				}
+			};
+			const safeResolve = (value) => {
+				if (!settled) {
+					settled = true;
+					clearTimeout(timer);
+					resolve$1(value);
+				}
+			};
+			let req;
+			const timer = setTimeout(() => {
+				req.destroy();
+				safeReject(new UpdateCheckError(`Update check timed out after ${this.timeoutMs}ms`));
+			}, this.timeoutMs);
+			const followRedirect = (location, hopsLeft) => {
+				const redirectReq = https.get(location, (redirectRes) => {
+					if (redirectRes.statusCode !== void 0 && redirectRes.statusCode >= 300 && redirectRes.statusCode < 400 && redirectRes.headers.location && hopsLeft > 0) {
+						redirectRes.resume();
+						followRedirect(redirectRes.headers.location, hopsLeft - 1);
+						return;
+					}
+					if (redirectRes.statusCode !== 200) {
+						redirectRes.resume();
+						safeReject(new UpdateCheckError(`npm registry returned HTTP ${String(redirectRes.statusCode)} for ${packageName}`));
+						return;
+					}
+					collectBody(redirectRes, safeResolve, safeReject);
+				});
+				redirectReq.on("error", (err) => {
+					safeReject(new UpdateCheckError(`Update check network error: ${err.message}`));
+				});
+				redirectReq.setTimeout(this.timeoutMs, () => {
+					redirectReq.destroy();
+					safeReject(new UpdateCheckError(`Update check timed out after ${this.timeoutMs}ms`));
+				});
+			};
+			req = https.get(url, (res) => {
+				if (res.statusCode !== void 0 && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+					res.resume();
+					followRedirect(res.headers.location, 1);
+					return;
+				}
+				if (res.statusCode !== 200) {
+					res.resume();
+					safeReject(new UpdateCheckError(`npm registry returned HTTP ${String(res.statusCode)} for ${packageName}`));
+					return;
+				}
+				collectBody(res, safeResolve, safeReject);
+			});
+			req.on("error", (err) => {
+				safeReject(new UpdateCheckError(`Update check network error: ${err.message}`));
+			});
+		});
+	}
+	/**
+	* Determine whether upgrading from currentVersion to latestVersion is a breaking (major) change.
+	*
+	* @param currentVersion - The currently installed version (semver string)
+	* @param latestVersion - The available latest version (semver string)
+	* @returns true if the major version increases; false if either version is invalid
+	*/
+	isBreaking(currentVersion, latestVersion) {
+		if (!semver.valid(currentVersion) || !semver.valid(latestVersion)) return false;
+		const currentMajor = semver.major(currentVersion);
+		const latestMajor = semver.major(latestVersion);
+		return latestMajor > currentMajor;
+	}
+	/**
+	* Return a changelog URL for the given version.
+	*
+	* @param latestVersion - The version to link to
+	* @returns A URL string pointing to the GitHub release page
+	*/
+	getChangelog(latestVersion) {
+		return `See https://github.com/jplanow/ai-dev-toolkit-new/releases/tag/v${latestVersion}`;
+	}
+};
+function collectBody(res, resolve$1, reject) {
+	const chunks = [];
+	res.on("data", (chunk) => {
+		chunks.push(chunk);
+	});
+	res.on("end", () => {
+		try {
+			const body = Buffer.concat(chunks).toString("utf-8");
+			const data = JSON.parse(body);
+			if (typeof data.version !== "string" || data.version.length === 0) {
+				reject(new UpdateCheckError("npm registry response missing version field"));
+				return;
+			}
+			resolve$1(data.version);
+		} catch {
+			reject(new UpdateCheckError("Failed to parse npm registry response"));
+		}
+	});
+	res.on("error", (err) => {
+		reject(new UpdateCheckError(`Response stream error: ${err.message}`));
+	});
+}
+
+//#endregion
+//#region src/modules/version-manager/version-cache.ts
+/**
+* Manages reading and writing the version check result cache.
+*
+* Write errors are silently swallowed so that a read-only home directory
+* never breaks CLI execution.
+*/
+var VersionCache = class {
+	cachePath;
+	ttlMs;
+	constructor(cachePath = path.join(os.homedir(), ".substrate", "update-cache.json"), ttlMs = 24 * 60 * 60 * 1e3) {
+		this.cachePath = cachePath;
+		this.ttlMs = ttlMs;
+	}
+	/**
+	* Read the cache file. Returns null if the file is missing, unreadable, or expired.
+	*/
+	read() {
+		try {
+			const raw = readFileSync(this.cachePath, "utf-8");
+			const entry = JSON.parse(raw);
+			if (typeof entry.lastChecked !== "string" || typeof entry.latestVersion !== "string" || typeof entry.currentVersion !== "string") return null;
+			if (this.isExpired(entry)) return null;
+			return entry;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Write a cache entry to disk. Creates the parent directory if needed.
+	* Silently swallows any write errors.
+	*/
+	write(entry) {
+		try {
+			mkdirSync(dirname(this.cachePath), { recursive: true });
+			writeFileSync(this.cachePath, JSON.stringify(entry, null, 2), "utf-8");
+		} catch {}
+	}
+	/**
+	* Check whether a cache entry has expired according to the configured TTL.
+	*/
+	isExpired(entry) {
+		const age = Date.now() - new Date(entry.lastChecked).getTime();
+		return age > this.ttlMs;
+	}
+};
+
+//#endregion
+//#region src/modules/version-manager/version-manager-impl.ts
+/**
+* Concrete implementation of VersionManager.
+*
+* @param deps - Optional overrides for cache and updateChecker (for testing)
+*/
+var VersionManagerImpl = class {
+	cache;
+	updateChecker;
+	updateCheckEnabled;
+	constructor(deps = {}) {
+		this.cache = deps.cache ?? new VersionCache();
+		this.updateChecker = deps.updateChecker ?? new UpdateChecker();
+		this.updateCheckEnabled = deps.updateCheckEnabled !== false;
+	}
+	/**
+	* Read the current package version from the bundled package.json.
+	* Falls back to '0.0.0' if the file is unreadable.
+	*/
+	getCurrentVersion() {
+		try {
+			const _require = createRequire(import.meta.url);
+			const pkg = _require("../../../package.json");
+			return typeof pkg.version === "string" && pkg.version.length > 0 ? pkg.version : "0.0.0";
+		} catch {
+			return "0.0.0";
+		}
+	}
+	/**
+	* Check whether a newer version is available on npm.
+	*
+	* Respects:
+	* 1. update_check config setting (AC5)
+	* 2. SUBSTRATE_NO_UPDATE_CHECK env var
+	* 3. Cache TTL (24h by default), unless forceRefresh is true
+	*
+	* Returns updateAvailable: false without a network call when checks are disabled
+	* or the cache is fresh (and forceRefresh is not set).
+	*
+	* @param forceRefresh - When true, skips the cache and always makes a fresh network request.
+	*/
+	async checkForUpdates(forceRefresh = false) {
+		const currentVersion = this.getCurrentVersion();
+		if (!this.updateCheckEnabled) return {
+			currentVersion,
+			latestVersion: currentVersion,
+			updateAvailable: false,
+			isBreaking: false,
+			changelog: ""
+		};
+		if (process.env["SUBSTRATE_NO_UPDATE_CHECK"] === "1") return {
+			currentVersion,
+			latestVersion: currentVersion,
+			updateAvailable: false,
+			isBreaking: false,
+			changelog: ""
+		};
+		if (!forceRefresh) {
+			const cached = this.cache.read();
+			if (cached !== null) {
+				const updateAvailable = cached.latestVersion !== cached.currentVersion;
+				return {
+					currentVersion: cached.currentVersion,
+					latestVersion: cached.latestVersion,
+					updateAvailable,
+					isBreaking: this.updateChecker.isBreaking(cached.currentVersion, cached.latestVersion),
+					changelog: this.updateChecker.getChangelog(cached.latestVersion)
+				};
+			}
+		}
+		try {
+			const latestVersion = await this.updateChecker.fetchLatestVersion("substrate");
+			const updateAvailable = latestVersion !== currentVersion;
+			this.cache.write({
+				lastChecked: new Date().toISOString(),
+				latestVersion,
+				currentVersion
+			});
+			return {
+				currentVersion,
+				latestVersion,
+				updateAvailable,
+				isBreaking: this.updateChecker.isBreaking(currentVersion, latestVersion),
+				changelog: this.updateChecker.getChangelog(latestVersion)
+			};
+		} catch {
+			return {
+				currentVersion,
+				latestVersion: currentVersion,
+				updateAvailable: false,
+				isBreaking: false,
+				changelog: ""
+			};
+		}
+	}
+	/**
+	* Return an upgrade preview for the given target version.
+	*/
+	getUpgradePreview(targetVersion) {
+		const fromVersion = this.getCurrentVersion();
+		const breaking = this.updateChecker.isBreaking(fromVersion, targetVersion);
+		return {
+			fromVersion,
+			toVersion: targetVersion,
+			breakingChanges: breaking ? [`Major version bump from v${fromVersion} to v${targetVersion}`] : [],
+			migrationSteps: [this.updateChecker.getChangelog(targetVersion)],
+			automaticMigrations: breaking ? ["Run defaultConfigMigrator.migrate() if config changed"] : [],
+			manualStepsRequired: breaking ? ["Review breaking changes at the changelog URL above"] : []
+		};
+	}
+	/**
+	* Migrate the project configuration from one format version to another.
+	* Delegates to the shared defaultConfigMigrator singleton.
+	* Loads the actual config from the project config file so migration functions receive real data.
+	*/
+	migrateConfiguration(fromVersion, toVersion) {
+		let configObj = {};
+		try {
+			const _require = createRequire(import.meta.url);
+			const fs = _require("fs");
+			const path$1 = _require("path");
+			const yaml = _require("js-yaml");
+			const configPath = path$1.join(process.cwd(), ".substrate", "config.yaml");
+			try {
+				const raw = fs.readFileSync(configPath, "utf-8");
+				configObj = yaml.load(raw) ?? {};
+			} catch {
+				configObj = {};
+			}
+		} catch {
+			configObj = {};
+		}
+		const { result } = defaultConfigMigrator.migrate(configObj, fromVersion, toVersion);
+		return result;
+	}
+	/**
+	* Migrate a task graph file from one format version to another.
+	* Delegates to the shared defaultConfigMigrator singleton.
+	*/
+	migrateTaskGraphFormat(fromVersion, toVersion, filePath) {
+		const { result } = defaultConfigMigrator.migrate({}, fromVersion, toVersion, filePath);
+		return result;
+	}
+	/**
+	* Check whether the given config format version is supported by this toolkit.
+	*/
+	isConfigCompatible(configVersion) {
+		return SUPPORTED_CONFIG_FORMAT_VERSIONS.includes(configVersion);
+	}
+	/**
+	* Check whether the given task graph format version is supported by this toolkit.
+	*/
+	isTaskGraphCompatible(graphVersion) {
+		return SUPPORTED_TASK_GRAPH_VERSIONS.includes(graphVersion);
+	}
+};
+/**
+* Create a new VersionManager instance with optional dependency overrides.
+*/
+function createVersionManager(deps = {}) {
+	return new VersionManagerImpl(deps);
+}
+
+//#endregion
+export { VersionManagerImpl, createVersionManager, defaultConfigMigrator };
+//# sourceMappingURL=version-manager-impl-DbHmed-I.js.map

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "substrate-ai",
+  "version": "0.1.0",
+  "description": "Substrate — multi-agent orchestration daemon for AI coding agents",
+  "type": "module",
+  "license": "MIT",
+  "author": "AI Dev Toolkit Contributors",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/johnplanow/substrate.git"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "orchestration",
+    "cli",
+    "task-graph",
+    "routing"
+  ],
+  "bin": {
+    "substrate": "./dist/cli/index.js"
+  },
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/cli/index.js",
+      "types": "./dist/cli/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.json",
+    "dist/cli/templates",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "postbuild": "cp -r src/cli/templates dist/cli/templates",
+    "dev": "tsx watch src/cli/index.ts",
+    "test": "vitest run --coverage",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "lint": "eslint src test",
+    "lint:fix": "eslint src test --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\"",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "better-sqlite3": "^12.6.2",
+    "commander": "^12.1.0",
+    "js-yaml": "^4.1.1",
+    "pino": "^9.6.0",
+    "semver": "^7.6.3",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.17.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.10.0",
+    "@types/semver": "^7.5.8",
+    "@typescript-eslint/eslint-plugin": "^8.18.0",
+    "@typescript-eslint/parser": "^8.18.0",
+    "@vitest/coverage-v8": "^2.1.8",
+    "@vitest/ui": "^2.1.8",
+    "eslint": "^9.17.0",
+    "pino-pretty": "^13.0.0",
+    "prettier": "^3.4.2",
+    "tsdown": "^0.9.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.9.0",
+    "typescript-eslint": "^8.18.0",
+    "vitest": "^2.1.8"
+  }
+}