openspecui 0.2.0 → 0.4.0

package/dist/{src-Bmm_kaB8.mjs → src-BS3LYQ6T.mjs}

@@ -4,12 +4,15 @@ import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
 import crypto from "crypto";
 import { EventEmitter } from "events";
-import { mkdir, readFile, readdir, rename, stat, writeFile } from "fs/promises";
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
 import { join } from "path";
-import { watch } from "fs";
-import { existsSync, readFileSync as readFileSync$1, statSync as statSync$1 } from "node:fs";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { readFile as readFile$1, readdir, stat } from "node:fs/promises";
+import { dirname as dirname$1, join as join$1, resolve as resolve$1 } from "node:path";
+import { existsSync, readFileSync, statSync, watch } from "node:fs";
+import { watch as watch$1 } from "fs";
+import { spawn } from "child_process";
 import { createServer as createServer$1 } from "node:net";
-import { dirname as dirname$1, join as join$1 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 //#region rolldown:runtime
@@ -376,7 +379,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
 				});
 				if (!chunk) {
 					if (i === 1) {
-						await new Promise((resolve$1) => setTimeout(resolve$1));
+						await new Promise((resolve$2) => setTimeout(resolve$2));
 						maxReadCount = 3;
 						continue;
 					}
@@ -6653,8 +6656,8 @@ var Unpromise = class Unpromise$1 {
 				status: "fulfilled",
 				value
 			};
-			subscribers === null || subscribers === void 0 || subscribers.forEach(({ resolve: resolve$1 }) => {
-				resolve$1(value);
+			subscribers === null || subscribers === void 0 || subscribers.forEach(({ resolve: resolve$2 }) => {
+				resolve$2(value);
 			});
 		});
 		if ("catch" in thenReturn) thenReturn.catch((reason) => {
@@ -6801,14 +6804,14 @@ function resolveSelfTuple(promise) {
 /** VENDORED (Future) PROMISE UTILITIES */
 /** Reference implementation of https://github.com/tc39/proposal-promise-with-resolvers */
 function withResolvers() {
-	let resolve$1;
+	let resolve$2;
 	let reject;
 	return {
 		promise: new Promise((_resolve, _reject) => {
-			resolve$1 = _resolve;
+			resolve$2 = _resolve;
 			reject = _reject;
 		}),
-		resolve: resolve$1,
+		resolve: resolve$2,
 		reject
 	};
 }
@@ -6864,8 +6867,8 @@ function timerResource(ms) {
 	let timer = null;
 	return makeResource({ start() {
 		if (timer) throw new Error("Timer already started");
-		return new Promise((resolve$1) => {
-			timer = setTimeout(() => resolve$1(disposablePromiseTimerResult), ms);
+		return new Promise((resolve$2) => {
+			timer = setTimeout(() => resolve$2(disposablePromiseTimerResult), ms);
 		});
 	} }, () => {
 		if (timer) clearTimeout(timer);
@@ -7082,14 +7085,14 @@ function _takeWithGrace() {
 	return _takeWithGrace.apply(this, arguments);
 }
 function createDeferred() {
-	let resolve$1;
+	let resolve$2;
 	let reject;
 	return {
 		promise: new Promise((res, rej) => {
-			resolve$1 = res;
+			resolve$2 = res;
 			reject = rej;
 		}),
-		resolve: resolve$1,
+		resolve: resolve$2,
 		reject
 	};
 }
@@ -8703,8 +8706,8 @@ function getWSConnectionHandler(opts) {
 					try {
 						var _usingCtx = (0, import_usingCtx.default)();
 						const iterator = _usingCtx.a(iteratorResource(iterable));
-						const abortPromise = new Promise((resolve$1) => {
-							abortController$1.signal.onabort = () => resolve$1("abort");
+						const abortPromise = new Promise((resolve$2) => {
+							abortController$1.signal.onabort = () => resolve$2("abort");
 						});
 						let next;
 						let result$1;
@@ -12716,6 +12719,390 @@ var Validator = class {
 	}
 };
 
+//#endregion
+//#region ../core/src/reactive-fs/reactive-state.ts
+/**
+* 全局的 AsyncLocalStorage，用于在异步调用链中传递 ReactiveContext
+* 这是实现依赖收集的核心机制
+*/
+const contextStorage = new AsyncLocalStorage();
+/**
+* 响应式状态类，类似 Signal.State
+*
+* 核心机制：
+* - get() 时自动注册到当前 ReactiveContext 的依赖列表
+* - set() 时如果值变化，通知所有依赖的 Context
+*/
+var ReactiveState = class {
+	currentValue;
+	equals;
+	/** 所有依赖此状态的 Context */
+	subscribers = /* @__PURE__ */ new Set();
+	constructor(initialValue, options) {
+		this.currentValue = initialValue;
+		this.equals = options?.equals ?? ((a, b) => a === b);
+	}
+	/**
+	* 获取当前值
+	* 如果在 ReactiveContext 中调用，会自动注册依赖
+	*/
+	get() {
+		const context = contextStorage.getStore();
+		if (context) {
+			context.track(this);
+			this.subscribers.add(context);
+		}
+		return this.currentValue;
+	}
+	/**
+	* 设置新值
+	* 如果值变化，通知所有订阅者
+	* @returns 是否发生了变化
+	*/
+	set(newValue) {
+		if (this.equals(this.currentValue, newValue)) return false;
+		this.currentValue = newValue;
+		for (const context of this.subscribers) context.notifyChange();
+		return true;
+	}
+	/**
+	* 取消订阅
+	* 当 Context 销毁时调用
+	*/
+	unsubscribe(context) {
+		this.subscribers.delete(context);
+	}
+	/**
+	* 获取当前订阅者数量（用于调试）
+	*/
+	get subscriberCount() {
+		return this.subscribers.size;
+	}
+};
+
+//#endregion
+//#region ../core/src/reactive-fs/reactive-context.ts
+function createPromiseWithResolvers() {
+	let resolve$2;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve$2 = res;
+			reject = rej;
+		}),
+		resolve: resolve$2,
+		reject
+	};
+}
+/**
+* 响应式上下文，管理依赖收集和变更通知
+*
+* 核心机制：
+* - 在 stream() 中执行任务时，通过 AsyncLocalStorage 传递 this
+* - 任务中的所有 ReactiveState.get() 调用都会自动注册依赖
+* - 当任何依赖变更时，重新执行任务并 yield 新结果
+*/
+var ReactiveContext = class {
+	/** 当前追踪的依赖 */
+	dependencies = /* @__PURE__ */ new Set();
+	/** 等待变更的 Promise */
+	changePromise;
+	/** 是否已销毁 */
+	destroyed = false;
+	/**
+	* 追踪依赖
+	* 由 ReactiveState.get() 调用
+	*/
+	track(state) {
+		if (!this.destroyed) this.dependencies.add(state);
+	}
+	/**
+	* 通知变更
+	* 由 ReactiveState.set() 调用
+	*/
+	notifyChange() {
+		if (!this.destroyed && this.changePromise) this.changePromise.resolve();
+	}
+	/**
+	* 运行响应式任务流
+	* 每次依赖变更时重新执行任务并 yield 结果
+	*
+	* @param task 要执行的异步任务
+	* @param signal 用于取消的 AbortSignal
+	*/
+	async *stream(task, signal) {
+		try {
+			while (!signal?.aborted && !this.destroyed) {
+				this.clearDependencies();
+				this.changePromise = createPromiseWithResolvers();
+				yield await contextStorage.run(this, task);
+				if (this.dependencies.size === 0) break;
+				await Promise.race([this.changePromise.promise, signal ? this.waitForAbort(signal) : new Promise(() => {})]);
+				if (signal?.aborted) break;
+			}
+		} finally {
+			this.destroy();
+		}
+	}
+	/**
+	* 执行一次任务（非响应式）
+	* 用于初始数据获取
+	*/
+	async runOnce(task) {
+		return contextStorage.run(this, task);
+	}
+	/**
+	* 清理依赖
+	*/
+	clearDependencies() {
+		for (const state of this.dependencies) state.unsubscribe(this);
+		this.dependencies.clear();
+	}
+	/**
+	* 销毁上下文
+	* @param reason 可选的销毁原因，如果提供则 reject changePromise
+	*/
+	destroy(reason) {
+		this.destroyed = true;
+		this.clearDependencies();
+		if (reason && this.changePromise) this.changePromise.reject(reason);
+		this.changePromise = void 0;
+	}
+	/**
+	* 等待 AbortSignal
+	*/
+	waitForAbort(signal) {
+		return new Promise((_, reject) => {
+			if (signal.aborted) {
+				reject(new DOMException("Aborted", "AbortError"));
+				return;
+			}
+			signal.addEventListener("abort", () => {
+				reject(new DOMException("Aborted", "AbortError"));
+			});
+		});
+	}
+};
+
+//#endregion
+//#region ../core/src/reactive-fs/watcher-pool.ts
+/** 全局监听器池，共享同一路径的监听器 */
+const watcherPool = /* @__PURE__ */ new Map();
+/** 防抖定时器 */
+const debounceTimers = /* @__PURE__ */ new Map();
+/** 默认防抖时间 (ms) */
+const DEBOUNCE_MS = 100;
+/**
+* 获取或创建文件/目录监听器
+*
+* 特性：
+* - 同一路径共享监听器
+* - 引用计数管理生命周期
+* - 内置防抖机制
+*
+* @param path 要监听的路径
+* @param onChange 变更回调
+* @param options 监听选项
+* @returns 释放函数，调用后取消订阅
+*/
+function acquireWatcher(path$1, onChange, options = {}) {
+	const normalizedPath = resolve$1(path$1);
+	const debounceMs = options.debounceMs ?? DEBOUNCE_MS;
+	let entry = watcherPool.get(normalizedPath);
+	if (!entry) {
+		const watcher = watch(normalizedPath, {
+			recursive: options.recursive ?? false,
+			persistent: false
+		}, () => {
+			const existingTimer = debounceTimers.get(normalizedPath);
+			if (existingTimer) clearTimeout(existingTimer);
+			const timer = setTimeout(() => {
+				debounceTimers.delete(normalizedPath);
+				const currentEntry = watcherPool.get(normalizedPath);
+				if (currentEntry) for (const cb of currentEntry.callbacks) try {
+					cb();
+				} catch (err) {
+					console.error(`Watcher callback error for ${normalizedPath}:`, err);
+				}
+			}, debounceMs);
+			debounceTimers.set(normalizedPath, timer);
+		});
+		watcher.on("error", (err) => {
+			console.error(`Watcher error for ${normalizedPath}:`, err);
+		});
+		entry = {
+			watcher,
+			refCount: 0,
+			callbacks: /* @__PURE__ */ new Set()
+		};
+		watcherPool.set(normalizedPath, entry);
+	}
+	entry.refCount++;
+	entry.callbacks.add(onChange);
+	return () => {
+		const currentEntry = watcherPool.get(normalizedPath);
+		if (!currentEntry) return;
+		currentEntry.callbacks.delete(onChange);
+		currentEntry.refCount--;
+		if (currentEntry.refCount === 0) {
+			currentEntry.watcher.close();
+			watcherPool.delete(normalizedPath);
+			const timer = debounceTimers.get(normalizedPath);
+			if (timer) {
+				clearTimeout(timer);
+				debounceTimers.delete(normalizedPath);
+			}
+		}
+	};
+}
+
+//#endregion
+//#region ../core/src/reactive-fs/reactive-fs.ts
+/** 状态缓存：路径 -> ReactiveState */
+const stateCache = /* @__PURE__ */ new Map();
+/** 监听器释放函数缓存 */
+const releaseCache = /* @__PURE__ */ new Map();
+/**
+* 响应式读取文件内容
+*
+* 特性：
+* - 自动注册文件监听
+* - 文件变更时自动更新状态
+* - 在 ReactiveContext 中调用时自动追踪依赖
+*
+* @param filepath 文件路径
+* @returns 文件内容，文件不存在时返回 null
+*/
+async function reactiveReadFile(filepath) {
+	const normalizedPath = resolve$1(filepath);
+	const key = `file:${normalizedPath}`;
+	const getValue = async () => {
+		try {
+			return await readFile$1(normalizedPath, "utf-8");
+		} catch {
+			return null;
+		}
+	};
+	let state = stateCache.get(key);
+	if (!state) {
+		state = new ReactiveState(await getValue());
+		stateCache.set(key, state);
+		const release = acquireWatcher(dirname$1(normalizedPath), async () => {
+			const newValue = await getValue();
+			state.set(newValue);
+		});
+		releaseCache.set(key, release);
+	}
+	return state.get();
+}
+/**
+* 响应式读取目录内容
+*
+* 特性：
+* - 自动注册目录监听
+* - 目录变更时自动更新状态
+* - 在 ReactiveContext 中调用时自动追踪依赖
+*
+* @param dirpath 目录路径
+* @param options 选项
+* @returns 目录项名称数组
+*/
+async function reactiveReadDir(dirpath, options = {}) {
+	const normalizedPath = resolve$1(dirpath);
+	const key = `dir:${normalizedPath}:${JSON.stringify(options)}`;
+	const getValue = async () => {
+		try {
+			return (await readdir(normalizedPath, { withFileTypes: true })).filter((entry) => {
+				if (!options.includeHidden && entry.name.startsWith(".")) return false;
+				if (options.exclude?.includes(entry.name)) return false;
+				if (options.directoriesOnly && !entry.isDirectory()) return false;
+				if (options.filesOnly && !entry.isFile()) return false;
+				return true;
+			}).map((entry) => entry.name);
+		} catch {
+			return [];
+		}
+	};
+	let state = stateCache.get(key);
+	if (!state) {
+		state = new ReactiveState(await getValue(), { equals: (a, b) => a.length === b.length && a.every((v, i) => v === b[i]) });
+		stateCache.set(key, state);
+		const release = acquireWatcher(normalizedPath, async () => {
+			const newValue = await getValue();
+			state.set(newValue);
+		}, { recursive: true });
+		releaseCache.set(key, release);
+	}
+	return state.get();
+}
+/**
+* 响应式检查路径是否存在
+*
+* @param path 路径
+* @returns 是否存在
+*/
+async function reactiveExists(path$1) {
+	const normalizedPath = resolve$1(path$1);
+	const key = `exists:${normalizedPath}`;
+	const getValue = async () => {
+		try {
+			await stat(normalizedPath);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	let state = stateCache.get(key);
+	if (!state) {
+		state = new ReactiveState(await getValue());
+		stateCache.set(key, state);
+		const release = acquireWatcher(dirname$1(normalizedPath), async () => {
+			const newValue = await getValue();
+			state.set(newValue);
+		});
+		releaseCache.set(key, release);
+	}
+	return state.get();
+}
+/**
+* 响应式获取文件/目录的 stat 信息
+*
+* @param path 路径
+* @returns stat 信息，不存在时返回 null
+*/
+async function reactiveStat(path$1) {
+	const normalizedPath = resolve$1(path$1);
+	const key = `stat:${normalizedPath}`;
+	const getValue = async () => {
+		try {
+			const s = await stat(normalizedPath);
+			return {
+				isDirectory: s.isDirectory(),
+				isFile: s.isFile(),
+				mtime: s.mtime.getTime(),
+				birthtime: s.birthtime.getTime()
+			};
+		} catch {
+			return null;
+		}
+	};
+	let state = stateCache.get(key);
+	if (!state) {
+		state = new ReactiveState(await getValue(), { equals: (a, b) => {
+			if (a === null && b === null) return true;
+			if (a === null || b === null) return false;
+			return a.isDirectory === b.isDirectory && a.isFile === b.isFile && a.mtime === b.mtime && a.birthtime === b.birthtime;
+		} });
+		stateCache.set(key, state);
+		const release = acquireWatcher(dirname$1(normalizedPath), async () => {
+			const newValue = await getValue();
+			state.set(newValue);
+		});
+		releaseCache.set(key, release);
+	}
+	return state.get();
+}
+
 //#endregion
 //#region ../core/src/adapter.ts
 /**
@@ -12741,93 +13128,101 @@ var OpenSpecAdapter = class {
 		return join(this.changesDir, "archive");
 	}
 	async isInitialized() {
-		try {
-			return (await stat(this.openspecDir)).isDirectory();
-		} catch {
-			return false;
-		}
+		return (await reactiveStat(this.openspecDir))?.isDirectory ?? false;
+	}
+	/** File time info derived from filesystem (reactive) */
+	async getFileTimeInfo(filePath) {
+		const statInfo = await reactiveStat(filePath);
+		if (!statInfo) return null;
+		return {
+			createdAt: statInfo.birthtime,
+			updatedAt: statInfo.mtime
+		};
 	}
 	async listSpecs() {
-		try {
-			return (await readdir(this.specsDir, { withFileTypes: true })).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
-		} catch {
-			return [];
-		}
+		return reactiveReadDir(this.specsDir, { directoriesOnly: true });
 	}
 	/**
-	* List specs with metadata (id and name)
+	* List specs with metadata (id, name, and time info)
+	* Only returns specs that have valid spec.md
+	* Sorted by updatedAt descending (most recent first)
 	*/
 	async listSpecsWithMeta() {
 		const ids = await this.listSpecs();
-		return await Promise.all(ids.map(async (id) => {
+		return (await Promise.all(ids.map(async (id) => {
+			const spec = await this.readSpec(id);
+			if (!spec) return null;
+			const specPath = join(this.specsDir, id, "spec.md");
+			const timeInfo = await this.getFileTimeInfo(specPath);
 			return {
 				id,
-				name: (await this.readSpec(id))?.name ?? id
+				name: spec.name,
+				createdAt: timeInfo?.createdAt ?? 0,
+				updatedAt: timeInfo?.updatedAt ?? 0
 			};
-		}));
+		}))).filter((r) => r !== null).sort((a, b) => b.updatedAt - a.updatedAt);
 	}
 	async listChanges() {
-		try {
-			return (await readdir(this.changesDir, { withFileTypes: true })).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "archive").map((e) => e.name);
-		} catch {
-			return [];
-		}
+		return reactiveReadDir(this.changesDir, {
+			directoriesOnly: true,
+			exclude: ["archive"]
+		});
 	}
 	/**
-	* List changes with metadata (id, name, and progress)
+	* List changes with metadata (id, name, progress, and time info)
+	* Only returns changes that have valid proposal.md
+	* Sorted by updatedAt descending (most recent first)
 	*/
 	async listChangesWithMeta() {
 		const ids = await this.listChanges();
-		return await Promise.all(ids.map(async (id) => {
+		return (await Promise.all(ids.map(async (id) => {
 			const change = await this.readChange(id);
+			if (!change) return null;
+			const proposalPath = join(this.changesDir, id, "proposal.md");
+			const timeInfo = await this.getFileTimeInfo(proposalPath);
 			return {
 				id,
-				name: change?.name ?? id,
-				progress: change?.progress ?? {
-					total: 0,
-					completed: 0
-				}
+				name: change.name,
+				progress: change.progress,
+				createdAt: timeInfo?.createdAt ?? 0,
+				updatedAt: timeInfo?.updatedAt ?? 0
 			};
-		}));
+		}))).filter((r) => r !== null).sort((a, b) => b.updatedAt - a.updatedAt);
 	}
 	async listArchivedChanges() {
-		try {
-			return (await readdir(this.archiveDir, { withFileTypes: true })).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
-		} catch {
-			return [];
-		}
+		return reactiveReadDir(this.archiveDir, { directoriesOnly: true });
 	}
 	/**
-	* List archived changes with metadata
+	* List archived changes with metadata and time info
+	* Only returns archives that have valid proposal.md
+	* Sorted by updatedAt descending (most recent first)
 	*/
 	async listArchivedChangesWithMeta() {
 		const ids = await this.listArchivedChanges();
-		return await Promise.all(ids.map(async (id) => {
+		return (await Promise.all(ids.map(async (id) => {
+			const change = await this.readArchivedChange(id);
+			if (!change) return null;
+			const proposalPath = join(this.archiveDir, id, "proposal.md");
+			const timeInfo = await this.getFileTimeInfo(proposalPath);
 			return {
 				id,
-				name: (await this.readArchivedChange(id))?.name ?? id
+				name: change.name,
+				createdAt: timeInfo?.createdAt ?? 0,
+				updatedAt: timeInfo?.updatedAt ?? 0
 			};
-		}));
+		}))).filter((r) => r !== null).sort((a, b) => b.updatedAt - a.updatedAt);
 	}
 	/**
-	* Read project.md content
+	* Read project.md content (reactive)
 	*/
 	async readProjectMd() {
-		try {
-			return await readFile(join(this.openspecDir, "project.md"), "utf-8");
-		} catch {
-			return null;
-		}
+		return reactiveReadFile(join(this.openspecDir, "project.md"));
 	}
 	/**
-	* Read AGENTS.md content
+	* Read AGENTS.md content (reactive)
 	*/
 	async readAgentsMd() {
-		try {
-			return await readFile(join(this.openspecDir, "AGENTS.md"), "utf-8");
-		} catch {
-			return null;
-		}
+		return reactiveReadFile(join(this.openspecDir, "AGENTS.md"));
 	}
 	/**
 	* Write project.md content
@@ -12851,11 +13246,7 @@ var OpenSpecAdapter = class {
 		}
 	}
 	async readSpecRaw(specId) {
-		try {
-			return await readFile(join(this.specsDir, specId, "spec.md"), "utf-8");
-		} catch {
-			return null;
-		}
+		return reactiveReadFile(join(this.specsDir, specId, "spec.md"));
 	}
 	async readChange(changeId) {
 		try {
@@ -12867,17 +13258,14 @@ var OpenSpecAdapter = class {
 		}
 	}
 	async readChangeRaw(changeId) {
-		try {
-			const proposalPath = join(this.changesDir, changeId, "proposal.md");
-			const tasksPath = join(this.changesDir, changeId, "tasks.md");
-			const [proposal, tasks] = await Promise.all([readFile(proposalPath, "utf-8"), readFile(tasksPath, "utf-8").catch(() => "")]);
-			return {
-				proposal,
-				tasks
-			};
-		} catch {
-			return null;
-		}
+		const proposalPath = join(this.changesDir, changeId, "proposal.md");
+		const tasksPath = join(this.changesDir, changeId, "tasks.md");
+		const [proposal, tasks] = await Promise.all([reactiveReadFile(proposalPath), reactiveReadFile(tasksPath)]);
+		if (!proposal) return null;
+		return {
+			proposal,
+			tasks: tasks ?? ""
+		};
 	}
 	/**
 	* Read an archived change
@@ -12892,20 +13280,17 @@ var OpenSpecAdapter = class {
 		}
 	}
 	/**
-	* Read raw archived change files
+	* Read raw archived change files (reactive)
 	*/
 	async readArchivedChangeRaw(changeId) {
-		try {
-			const proposalPath = join(this.archiveDir, changeId, "proposal.md");
-			const tasksPath = join(this.archiveDir, changeId, "tasks.md");
-			const [proposal, tasks] = await Promise.all([readFile(proposalPath, "utf-8"), readFile(tasksPath, "utf-8").catch(() => "")]);
-			return {
-				proposal,
-				tasks
-			};
-		} catch {
-			return null;
-		}
+		const proposalPath = join(this.archiveDir, changeId, "proposal.md");
+		const tasksPath = join(this.archiveDir, changeId, "tasks.md");
+		const [proposal, tasks] = await Promise.all([reactiveReadFile(proposalPath), reactiveReadFile(tasksPath)]);
+		if (!proposal) return null;
+		return {
+			proposal,
+			tasks: tasks ?? ""
+		};
 	}
 	async writeSpec(specId, content) {
 		const specDir = join(this.specsDir, specId);
@@ -13222,7 +13607,7 @@ var OpenSpecWatcher = class extends EventEmitter {
 	*/
 	watchDir(dir, callback) {
 		try {
-			const watcher = watch(dir, { recursive: true }, (eventType, filename) => {
+			const watcher = watch$1(dir, { recursive: true }, (eventType, filename) => {
 				if (filename) callback(filename, eventType);
 			});
 			watcher.on("error", (error) => {
@@ -13247,6 +13632,397 @@ var OpenSpecWatcher = class extends EventEmitter {
 	}
 };
 
+//#endregion
+//#region ../core/src/config.ts
+/**
+* OpenSpecUI 配置 Schema
+*
+* 存储在 openspec/.openspecui.json 中，利用文件监听实现响应式更新
+*/
+const OpenSpecUIConfigSchema = objectType({
+	cli: objectType({ command: stringType().default("npx @fission-ai/openspec") }).default({}),
+	ui: objectType({ theme: enumType([
+		"light",
+		"dark",
+		"system"
+	]).default("system") }).default({})
+});
+/** 默认配置 */
+const DEFAULT_CONFIG = {
+	cli: { command: "npx @fission-ai/openspec" },
+	ui: { theme: "system" }
+};
+/**
+* 配置管理器
+*
+* 负责读写 openspec/.openspecui.json 配置文件。
+* 读取操作使用 reactiveReadFile，支持响应式更新。
+*/
+var ConfigManager = class {
+	configPath;
+	constructor(projectDir) {
+		this.configPath = join(projectDir, "openspec", ".openspecui.json");
+	}
+	/**
+	* 读取配置（响应式）
+	*
+	* 如果配置文件不存在，返回默认配置。
+	* 如果配置文件格式错误，返回默认配置并打印警告。
+	*/
+	async readConfig() {
+		const content = await reactiveReadFile(this.configPath);
+		if (!content) return DEFAULT_CONFIG;
+		try {
+			const parsed = JSON.parse(content);
+			const result = OpenSpecUIConfigSchema.safeParse(parsed);
+			if (result.success) return result.data;
+			console.warn("Invalid config format, using defaults:", result.error.message);
+			return DEFAULT_CONFIG;
+		} catch (err) {
+			console.warn("Failed to parse config, using defaults:", err);
+			return DEFAULT_CONFIG;
+		}
+	}
+	/**
+	* 写入配置
+	*
+	* 会触发文件监听，自动更新订阅者。
+	*/
+	async writeConfig(config) {
+		const current = await this.readConfig();
+		const merged = {
+			...current,
+			...config,
+			cli: {
+				...current.cli,
+				...config.cli
+			},
+			ui: {
+				...current.ui,
+				...config.ui
+			}
+		};
+		await writeFile(this.configPath, JSON.stringify(merged, null, 2), "utf-8");
+	}
+	/**
+	* 获取 CLI 命令
+	*/
+	async getCliCommand() {
+		return (await this.readConfig()).cli.command;
+	}
+	/**
+	* 设置 CLI 命令
+	*/
+	async setCliCommand(command) {
+		await this.writeConfig({ cli: { command } });
+	}
+};
+
+//#endregion
+//#region ../core/src/cli-executor.ts
+/**
+* CLI 执行器
+*
+* 负责调用外部 openspec CLI 命令。
+* 命令前缀从 ConfigManager 获取，支持：
+* - npx @fission-ai/openspec (默认)
+* - bunx openspec
+* - openspec (本地安装)
+* - 自定义命令 (如 xspec)
+*/
+var CliExecutor = class {
+	constructor(configManager, projectDir) {
+		this.configManager = configManager;
+		this.projectDir = projectDir;
+	}
+	/**
+	* 创建干净的环境变量，移除 pnpm 特有的配置
+	* 避免 pnpm 环境变量污染 npx/npm 执行
+	*/
+	getCleanEnv() {
+		const env = { ...process.env };
+		for (const key of Object.keys(env)) if (key.startsWith("npm_config_") || key.startsWith("npm_package_") || key === "npm_execpath" || key === "npm_lifecycle_event" || key === "npm_lifecycle_script") delete env[key];
+		return env;
+	}
+	/**
+	* 执行 CLI 命令
+	*
+	* @param args CLI 参数，如 ['init'] 或 ['archive', 'change-id']
+	* @returns 执行结果
+	*/
+	async execute(args) {
+		const parts = (await this.configManager.getCliCommand()).split(/\s+/);
+		const cmd = parts[0];
+		const cmdArgs = [...parts.slice(1), ...args];
+		return new Promise((resolve$2) => {
+			const child = spawn(cmd, cmdArgs, {
+				cwd: this.projectDir,
+				shell: true,
+				env: this.getCleanEnv()
+			});
+			let stdout = "";
+			let stderr = "";
+			child.stdout?.on("data", (data) => {
+				stdout += data.toString();
+			});
+			child.stderr?.on("data", (data) => {
+				stderr += data.toString();
+			});
+			child.on("close", (exitCode) => {
+				resolve$2({
+					success: exitCode === 0,
+					stdout,
+					stderr,
+					exitCode
+				});
+			});
+			child.on("error", (err) => {
+				resolve$2({
+					success: false,
+					stdout,
+					stderr: stderr + "\n" + err.message,
+					exitCode: null
+				});
+			});
+		});
+	}
+	/**
+	* 执行 openspec init（非交互式）
+	*
+	* @param tools 工具列表，如 ['claude', 'cursor'] 或 'all' 或 'none'
+	*/
+	async init(tools = "all") {
+		const toolsArg = Array.isArray(tools) ? tools.join(",") : tools;
+		return this.execute(["init", `--tools=${toolsArg}`]);
+	}
+	/**
+	* 执行 openspec archive <changeId>（非交互式）
+	*
+	* @param changeId 要归档的 change ID
+	* @param options 选项
+	*/
+	async archive(changeId, options = {}) {
+		const args = [
+			"archive",
+			"-y",
+			changeId
+		];
+		if (options.skipSpecs) args.push("--skip-specs");
+		if (options.noValidate) args.push("--no-validate");
+		return this.execute(args);
+	}
+	/**
+	* 执行 openspec validate [type] [id]
+	*/
+	async validate(type, id) {
+		const args = ["validate"];
+		if (type) args.push(type);
+		if (id) args.push(id);
+		return this.execute(args);
+	}
+	/**
+	* 检查 CLI 是否可用
+	*/
+	async checkAvailability() {
+		try {
+			const result = await this.execute(["--version"]);
+			if (result.success) return {
+				available: true,
+				version: result.stdout.trim()
+			};
+			return {
+				available: false,
+				error: result.stderr || "Unknown error"
+			};
+		} catch (err) {
+			return {
+				available: false,
+				error: err instanceof Error ? err.message : "Unknown error"
+			};
+		}
+	}
+};
+
+//#endregion
+//#region ../core/src/tool-config.ts
+/**
+* 工具配置检测模块
+*
+* 基于 @fission-ai/openspec 的 configurators 实现
+* 用于检测项目中已配置的 AI 工具
+*
+* 重要：使用响应式文件系统 (reactiveExists) 实现，
+* 当配置文件变化时会自动触发更新。
+*
+* @see references/openspec/src/core/configurators/slash/
+*/
+/**
+* 所有支持的工具配置
+*
+* 检测路径使用 proposal 命令文件，因为这是 openspec init 创建的第一个文件
+* 如果该文件存在，说明工具已配置
+*/
+const TOOL_CONFIGS = [
+	{
+		toolId: "claude",
+		detectionPath: ".claude/commands/openspec/proposal.md"
+	},
+	{
+		toolId: "cursor",
+		detectionPath: ".cursor/commands/openspec-proposal.md"
+	},
+	{
+		toolId: "windsurf",
+		detectionPath: ".windsurf/workflows/openspec-proposal.md"
+	},
+	{
+		toolId: "cline",
+		detectionPath: ".clinerules/workflows/openspec-proposal.md"
+	},
+	{
+		toolId: "github-copilot",
+		detectionPath: ".github/prompts/openspec-proposal.prompt.md"
+	},
+	{
+		toolId: "amazon-q",
+		detectionPath: ".amazonq/prompts/openspec-proposal.md"
+	},
+	{
+		toolId: "codex",
+		detectionPath: ".codex/prompts/openspec-proposal.md"
+	},
+	{
+		toolId: "gemini",
+		detectionPath: ".gemini/commands/openspec/proposal.toml"
+	},
+	{
+		toolId: "auggie",
+		detectionPath: ".augment/commands/openspec-proposal.md"
+	},
+	{
+		toolId: "codebuddy",
+		detectionPath: ".codebuddy/commands/openspec/proposal.md"
+	},
+	{
+		toolId: "qoder",
+		detectionPath: ".qoder/commands/openspec/proposal.md"
+	},
+	{
+		toolId: "roocode",
+		detectionPath: ".roo/commands/openspec-proposal.md"
+	},
+	{
+		toolId: "kilocode",
+		detectionPath: ".kilocode/workflows/openspec-proposal.md"
+	},
+	{
+		toolId: "opencode",
+		detectionPath: ".opencode/command/openspec-proposal.md"
+	},
+	{
+		toolId: "factory",
+		detectionPath: ".factory/commands/openspec-proposal.md"
+	},
+	{
+		toolId: "crush",
+		detectionPath: ".crush/commands/openspec/proposal.md"
+	},
+	{
+		toolId: "costrict",
+		detectionPath: ".cospec/openspec/commands/openspec-proposal.md"
+	},
+	{
+		toolId: "qwen",
+		detectionPath: ".qwen/commands/openspec-proposal.toml"
+	},
+	{
+		toolId: "iflow",
+		detectionPath: ".iflow/commands/openspec-proposal.md"
+	},
+	{
+		toolId: "antigravity",
+		detectionPath: ".agent/workflows/openspec-proposal.md"
+	}
+];
+/**
+* 获取所有可用的工具 ID 列表
+*/
+function getAvailableToolIds() {
+	return TOOL_CONFIGS.map((config) => config.toolId);
+}
+/**
+* 检测项目中已配置的工具（响应式）
+*
+* 使用 reactiveExists 检测文件，当文件变化时会自动触发更新。
+* 必须在 ReactiveContext 中调用才能获得响应式能力。
+*
+* @param projectDir 项目根目录
+* @returns 已配置的工具 ID 列表
+*/
+async function getConfiguredTools(projectDir) {
+	const configured = [];
+	for (const config of TOOL_CONFIGS) if (await reactiveExists(join(projectDir, config.detectionPath))) configured.push(config.toolId);
+	return configured;
+}
+
+//#endregion
+//#region ../server/src/reactive-subscription.ts
+/**
+* 创建响应式订阅
+*
+* 自动追踪 task 中的文件依赖，当依赖变更时自动重新执行并推送新数据。
+*
+* @param task 要执行的异步任务，内部的文件读取会被自动追踪
+* @returns tRPC observable
+*
+* @example
+* ```typescript
+* // 在 router 中使用
+* subscribe: publicProcedure.subscription(({ ctx }) => {
+*   return createReactiveSubscription(() => ctx.adapter.listSpecsWithMeta())
+* })
+* ```
+*/
+function createReactiveSubscription(task) {
+	return observable((emit) => {
+		const context = new ReactiveContext();
+		const controller = new AbortController();
+		(async () => {
+			try {
+				for await (const data of context.stream(task, controller.signal)) emit.next(data);
+			} catch (err) {
+				if (!controller.signal.aborted) emit.error(err);
+			}
+		})();
+		return () => {
+			controller.abort();
+		};
+	});
+}
+/**
+* 创建带输入参数的响应式订阅
+*
+* @param task 接收输入参数的异步任务
+* @returns 返回一个函数，接收输入参数并返回 tRPC observable
+*
+* @example
+* ```typescript
+* // 在 router 中使用
+* subscribeOne: publicProcedure
+*   .input(z.object({ id: z.string() }))
+*   .subscription(({ ctx, input }) => {
+*     return createReactiveSubscriptionWithInput(
+*       (id: string) => ctx.adapter.readSpec(id)
+*     )(input.id)
+*   })
+* ```
+*/
+function createReactiveSubscriptionWithInput(task) {
+	return (input) => {
+		return createReactiveSubscription(() => task(input));
+	};
+}
+
 //#endregion
 //#region ../server/src/router.ts
 const t = initTRPC.context().create();
@@ -13261,6 +14037,12 @@ const dashboardRouter = router({
 	}),
 	isInitialized: publicProcedure.query(async ({ ctx }) => {
 		return ctx.adapter.isInitialized();
+	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.getDashboardData());
+	}),
+	subscribeInitialized: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.isInitialized());
 	})
 });
 /**
@@ -13288,6 +14070,15 @@ const specRouter = router({
 	}),
 	validate: publicProcedure.input(objectType({ id: stringType() })).query(async ({ ctx, input }) => {
 		return ctx.adapter.validateSpec(input.id);
+	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.listSpecsWithMeta());
+	}),
+	subscribeOne: publicProcedure.input(objectType({ id: stringType() })).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readSpec(id))(input.id);
+	}),
+	subscribeRaw: publicProcedure.input(objectType({ id: stringType() })).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readSpecRaw(id))(input.id);
 	})
 });
 /**
@@ -13330,6 +14121,15 @@ const changeRouter = router({
 	})).mutation(async ({ ctx, input }) => {
 		if (!await ctx.adapter.toggleTask(input.changeId, input.taskIndex, input.completed)) throw new Error(`Failed to toggle task ${input.taskIndex} in change ${input.changeId}`);
 		return { success: true };
+	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.listChangesWithMeta());
+	}),
+	subscribeOne: publicProcedure.input(objectType({ id: stringType() })).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readChange(id))(input.id);
+	}),
+	subscribeRaw: publicProcedure.input(objectType({ id: stringType() })).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readChangeRaw(id))(input.id);
 	})
 });
 /**
@@ -13427,6 +14227,12 @@ const projectRouter = router({
 	saveAgentsMd: publicProcedure.input(objectType({ content: stringType() })).mutation(async ({ ctx, input }) => {
 		await ctx.adapter.writeAgentsMd(input.content);
 		return { success: true };
+	}),
+	subscribeProjectMd: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.readProjectMd());
+	}),
+	subscribeAgentsMd: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.readAgentsMd());
 	})
 });
 /**
@@ -13444,6 +14250,12 @@ const archiveRouter = router({
 	}),
 	getRaw: publicProcedure.input(objectType({ id: stringType() })).query(async ({ ctx, input }) => {
 		return ctx.adapter.readArchivedChangeRaw(input.id);
+	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.listArchivedChangesWithMeta());
+	}),
+	subscribeOne: publicProcedure.input(objectType({ id: stringType() })).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readArchivedChange(id))(input.id);
 	})
 });
 objectType({
@@ -13517,6 +14329,75 @@ const realtimeRouter = router({
 	})
 });
 /**
+* Config router - configuration management
+*/
+const configRouter = router({
+	get: publicProcedure.query(async ({ ctx }) => {
+		return ctx.configManager.readConfig();
+	}),
+	update: publicProcedure.input(objectType({
+		cli: objectType({ command: stringType() }).optional(),
+		ui: objectType({ theme: enumType([
+			"light",
+			"dark",
+			"system"
+		]) }).optional()
+	})).mutation(async ({ ctx, input }) => {
+		await ctx.configManager.writeConfig(input);
+		return { success: true };
+	}),
+	setCliCommand: publicProcedure.input(objectType({ command: stringType() })).mutation(async ({ ctx, input }) => {
+		await ctx.configManager.setCliCommand(input.command);
+		return { success: true };
+	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.configManager.readConfig());
+	})
+});
+/**
+* CLI router - execute external openspec CLI commands
+*/
+const cliRouter = router({
+	checkAvailability: publicProcedure.query(async ({ ctx }) => {
+		return ctx.cliExecutor.checkAvailability();
+	}),
+	getAvailableTools: publicProcedure.query(() => {
+		return getAvailableToolIds();
+	}),
+	getConfiguredTools: publicProcedure.query(async ({ ctx }) => {
+		return getConfiguredTools(ctx.projectDir);
+	}),
+	subscribeConfiguredTools: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => getConfiguredTools(ctx.projectDir));
+	}),
+	init: publicProcedure.input(objectType({ tools: unionType([
+		arrayType(stringType()),
+		literalType("all"),
+		literalType("none")
+	]).optional() }).optional()).mutation(async ({ ctx, input }) => {
+		return ctx.cliExecutor.init(input?.tools ?? "all");
+	}),
+	archive: publicProcedure.input(objectType({
+		changeId: stringType(),
+		skipSpecs: booleanType().optional(),
+		noValidate: booleanType().optional()
+	})).mutation(async ({ ctx, input }) => {
+		return ctx.cliExecutor.archive(input.changeId, {
+			skipSpecs: input.skipSpecs,
+			noValidate: input.noValidate
+		});
+	}),
+	validate: publicProcedure.input(objectType({
+		type: enumType(["spec", "change"]).optional(),
+		id: stringType().optional()
+	})).mutation(async ({ ctx, input }) => {
+		return ctx.cliExecutor.validate(input.type, input.id);
+	}),
+	execute: publicProcedure.input(objectType({ args: arrayType(stringType()) })).mutation(async ({ ctx, input }) => {
+		return ctx.cliExecutor.execute(input.args);
+	})
+});
+/**
 * Main app router
 */
 const appRouter = router({
@@ -13527,7 +14408,9 @@ const appRouter = router({
 	project: projectRouter,
 	ai: aiRouter,
 	init: initRouter,
-	realtime: realtimeRouter
+	realtime: realtimeRouter,
+	config: configRouter,
+	cli: cliRouter
 });
 
 //#endregion
@@ -13550,6 +14433,8 @@ const appRouter = router({
 function createServer$2(config) {
 	const adapter = new OpenSpecAdapter(config.projectDir);
 	const providerManager = new ProviderManager(config.providers);
+	const configManager = new ConfigManager(config.projectDir);
+	const cliExecutor = new CliExecutor(configManager, config.projectDir);
 	const watcher = config.enableWatcher !== false ? new OpenSpecWatcher(config.projectDir) : void 0;
 	const app = new Hono();
 	const corsOrigins = config.corsOrigins ?? ["http://localhost:5173", "http://localhost:3000"];
@@ -13572,19 +14457,27 @@ function createServer$2(config) {
 			createContext: () => ({
 				adapter,
 				providerManager,
-				watcher
+				configManager,
+				cliExecutor,
+				watcher,
+				projectDir: config.projectDir
 			})
 		});
 	});
 	const createContext = () => ({
 		adapter,
 		providerManager,
-		watcher
+		configManager,
+		cliExecutor,
+		watcher,
+		projectDir: config.projectDir
 	});
 	return {
 		app,
 		adapter,
 		providerManager,
+		configManager,
+		cliExecutor,
 		watcher,
 		createContext,
 		port: config.port ?? 3100
@@ -13622,18 +14515,28 @@ function createWebSocketServer(server, httpServer) {
 //#region src/index.ts
 const __dirname = dirname$1(fileURLToPath(import.meta.url));
 /**
-* Check if a port is available by trying to listen on it
+* Check if a port is available by trying to listen on it.
+* Tests both 127.0.0.1 and 0.0.0.0 to ensure the port is truly available.
 */
 function isPortAvailable(port) {
-	return new Promise((resolve$1) => {
-		const server = createServer$1();
-		server.once("error", () => {
-			resolve$1(false);
-		});
-		server.once("listening", () => {
-			server.close(() => resolve$1(true));
+	return new Promise((resolve$2) => {
+		const server1 = createServer$1();
+		server1.once("error", () => {
+			resolve$2(false);
+		});
+		server1.once("listening", () => {
+			server1.close(() => {
+				const server2 = createServer$1();
+				server2.once("error", () => {
+					resolve$2(false);
+				});
+				server2.once("listening", () => {
+					server2.close(() => resolve$2(true));
+				});
+				server2.listen(port, "0.0.0.0");
+			});
 		});
-		server.listen(port, "0.0.0.0");
+		server1.listen(port, "127.0.0.1");
 	});
 }
 /**
@@ -13702,8 +14605,8 @@ async function startServer(options = {}) {
 		const path$1 = c.req.path === "/" ? "/index.html" : c.req.path;
 		if (path$1.startsWith("/trpc")) return next();
 		const filePath = join$1(webDir, path$1);
-		if (existsSync(filePath) && statSync$1(filePath).isFile()) {
-			const content = readFileSync$1(filePath);
+		if (existsSync(filePath) && statSync(filePath).isFile()) {
+			const content = readFileSync(filePath);
 			const contentType = {
 				html: "text/html",
 				js: "application/javascript",
@@ -13724,7 +14627,7 @@ async function startServer(options = {}) {
 		if (!path$1.includes(".")) {
 			const indexPath = join$1(webDir, "index.html");
 			if (existsSync(indexPath)) {
-				const content = readFileSync$1(indexPath, "utf-8");
+				const content = readFileSync(indexPath, "utf-8");
 				return c.html(content);
 			}
 		}