@oh-my-pi/pi-coding-agent 4.2.1 → 4.2.2

package/src/discovery/helpers.ts

@@ -2,8 +2,9 @@
  * Shared helpers for discovery providers.
  */
 
-import { join, resolve } from "path";
+import { join, resolve } from "node:path";
 import { parse as parseYAML } from "yaml";
+import { readDirEntries, readFile } from "../capability/fs";
 import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 
@@ -71,16 +72,13 @@ export function getUserPath(ctx: LoadContext, source: SourceId, subpath: string)
 }
 
 /**
- * Get project-level path for a source (walks up from cwd).
+ * Get project-level path for a source (cwd only).
  */
 export function getProjectPath(ctx: LoadContext, source: SourceId, subpath: string): string | null {
 	const paths = SOURCE_PATHS[source];
 	if (!paths.projectDir) return null;
 
-	const found = ctx.fs.walkUp(paths.projectDir, { dir: true });
-	if (!found) return null;
-
-	return join(found, subpath);
+	return join(ctx.cwd, paths.projectDir, subpath);
 }
 
 /**
@@ -127,51 +125,54 @@ export function parseFrontmatter(content: string): {
 	}
 }
 
-export function loadSkillsFromDir(
-	ctx: LoadContext,
+export async function loadSkillsFromDir(
+	_ctx: LoadContext,
 	options: {
 		dir: string;
 		providerId: string;
 		level: "user" | "project";
 		requireDescription?: boolean;
 	},
-): LoadResult<Skill> {
+): Promise<LoadResult<Skill>> {
 	const items: Skill[] = [];
 	const warnings: string[] = [];
 	const { dir, level, providerId, requireDescription = false } = options;
 
-	if (!ctx.fs.isDir(dir)) {
-		return { items, warnings };
-	}
-
-	for (const name of ctx.fs.readDir(dir)) {
-		if (name.startsWith(".") || name === "node_modules") continue;
-
-		const skillDir = join(dir, name);
-		if (!ctx.fs.isDir(skillDir)) continue;
-
-		const skillFile = join(skillDir, "SKILL.md");
-		if (!ctx.fs.isFile(skillFile)) continue;
-
-		const content = ctx.fs.readFile(skillFile);
-		if (!content) {
-			warnings.push(`Failed to read ${skillFile}`);
-			continue;
-		}
+	const entries = await readDirEntries(dir);
+	const skillDirs = entries.filter(
+		(entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules",
+	);
+
+	const results = await Promise.all(
+		skillDirs.map(async (entry) => {
+			const skillFile = join(dir, entry.name, "SKILL.md");
+			const content = await readFile(skillFile);
+			if (!content) {
+				return { item: null as Skill | null, warning: null as string | null };
+			}
 
-		const { frontmatter, body } = parseFrontmatter(content);
-		if (requireDescription && !frontmatter.description) {
-			continue;
-		}
+			const { frontmatter, body } = parseFrontmatter(content);
+			if (requireDescription && !frontmatter.description) {
+				return { item: null as Skill | null, warning: null as string | null };
+			}
 
-		items.push({
-			name: (frontmatter.name as string) || name,
-			path: skillFile,
-			content: body,
-			frontmatter: frontmatter as SkillFrontmatter,
-			level,
-			_source: createSourceMeta(providerId, skillFile, level),
-		});
+			return {
+				item: {
+					name: (frontmatter.name as string) || entry.name,
+					path: skillFile,
+					content: body,
+					frontmatter: frontmatter as SkillFrontmatter,
+					level,
+					_source: createSourceMeta(providerId, skillFile, level),
+				},
+				warning: null as string | null,
+			};
+		}),
+	);
+
+	for (const result of results) {
+		if (result.warning) warnings.push(result.warning);
+		if (result.item) items.push(result.item);
 	}
 
 	return { items, warnings };
@@ -213,8 +214,8 @@ export function expandEnvVarsDeep<T>(obj: T, extraEnv?: Record<string, string>):
 /**
  * Load files from a directory matching a pattern.
  */
-export function loadFilesFromDir<T>(
-	ctx: LoadContext,
+export async function loadFilesFromDir<T>(
+	_ctx: LoadContext,
 	dir: string,
 	provider: string,
 	level: "user" | "project",
@@ -226,37 +227,40 @@ export function loadFilesFromDir<T>(
 		/** Whether to recurse into subdirectories */
 		recursive?: boolean;
 	},
-): LoadResult<T> {
-	const items: T[] = [];
-	const warnings: string[] = [];
+): Promise<LoadResult<T>> {
+	const entries = await readDirEntries(dir);
 
-	if (!ctx.fs.isDir(dir)) {
-		return { items, warnings };
-	}
+	const visibleEntries = entries.filter((entry) => !entry.name.startsWith("."));
 
-	const files = ctx.fs.readDir(dir);
+	const directories = options.recursive ? visibleEntries.filter((entry) => entry.isDirectory()) : [];
 
-	for (const name of files) {
-		if (name.startsWith(".")) continue;
+	const files = visibleEntries
+		.filter((entry) => entry.isFile())
+		.filter((entry) => {
+			if (!options.extensions) return true;
+			return options.extensions.some((ext) => entry.name.endsWith(`.${ext}`));
+		});
 
-		const path = join(dir, name);
+	const [subResults, fileResults] = await Promise.all([
+		Promise.all(directories.map((entry) => loadFilesFromDir(_ctx, join(dir, entry.name), provider, level, options))),
+		Promise.all(
+			files.map(async (entry) => {
+				const path = join(dir, entry.name);
+				const content = await readFile(path);
+				return { entry, path, content };
+			}),
+		),
+	]);
 
-		if (options.recursive && ctx.fs.isDir(path)) {
-			const subResult = loadFilesFromDir(ctx, path, provider, level, options);
-			items.push(...subResult.items);
-			if (subResult.warnings) warnings.push(...subResult.warnings);
-			continue;
-		}
-
-		if (!ctx.fs.isFile(path)) continue;
+	const items: T[] = [];
+	const warnings: string[] = [];
 
-		// Check extension
-		if (options.extensions) {
-			const hasMatch = options.extensions.some((ext) => name.endsWith(`.${ext}`));
-			if (!hasMatch) continue;
-		}
+	for (const subResult of subResults) {
+		items.push(...subResult.items);
+		if (subResult.warnings) warnings.push(...subResult.warnings);
+	}
 
-		const content = ctx.fs.readFile(path);
+	for (const { entry, path, content } of fileResults) {
 		if (content === null) {
 			warnings.push(`Failed to read file: ${path}`);
 			continue;
@@ -265,7 +269,7 @@ export function loadFilesFromDir<T>(
 		const source = createSourceMeta(provider, path, level);
 
 		try {
-			const item = options.transform(name, content, path, source);
+			const item = options.transform(entry.name, content, path, source);
 			if (item !== null) {
 				items.push(item);
 			}
@@ -303,8 +307,11 @@ interface ExtensionModuleManifest {
 	extensions?: string[];
 }
 
-function readExtensionModuleManifest(ctx: LoadContext, packageJsonPath: string): ExtensionModuleManifest | null {
-	const content = ctx.fs.readFile(packageJsonPath);
+async function readExtensionModuleManifest(
+	_ctx: LoadContext,
+	packageJsonPath: string,
+): Promise<ExtensionModuleManifest | null> {
+	const content = await readFile(packageJsonPath);
 	if (!content) return null;
 
 	const pkg = parseJSON<{ omp?: ExtensionModuleManifest; pi?: ExtensionModuleManifest }>(content);
@@ -329,34 +336,35 @@ function isExtensionModuleFile(name: string): boolean {
  *
  * No recursion beyond one level. Complex packages must use package.json manifest.
  */
-export function discoverExtensionModulePaths(ctx: LoadContext, dir: string): string[] {
-	if (!ctx.fs.isDir(dir)) {
-		return [];
-	}
-
+export async function discoverExtensionModulePaths(ctx: LoadContext, dir: string): Promise<string[]> {
 	const discovered: string[] = [];
+	const entries = await readDirEntries(dir);
 
-	for (const name of ctx.fs.readDir(dir)) {
-		if (name.startsWith(".") || name === "node_modules") continue;
+	for (const entry of entries) {
+		if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
 
-		const entryPath = join(dir, name);
+		const entryPath = join(dir, entry.name);
 
 		// 1. Direct files: *.ts or *.js
-		if (ctx.fs.isFile(entryPath) && isExtensionModuleFile(name)) {
+		if (entry.isFile() && isExtensionModuleFile(entry.name)) {
 			discovered.push(entryPath);
 			continue;
 		}
 
 		// 2 & 3. Subdirectories
-		if (ctx.fs.isDir(entryPath)) {
+		if (entry.isDirectory()) {
+			const subEntries = await readDirEntries(entryPath);
+			const subFileNames = new Set(subEntries.filter((e) => e.isFile()).map((e) => e.name));
+
 			// Check for package.json with "omp"/"pi" field first
-			const packageJsonPath = join(entryPath, "package.json");
-			if (ctx.fs.isFile(packageJsonPath)) {
-				const manifest = readExtensionModuleManifest(ctx, packageJsonPath);
+			if (subFileNames.has("package.json")) {
+				const packageJsonPath = join(entryPath, "package.json");
+				const manifest = await readExtensionModuleManifest(ctx, packageJsonPath);
 				if (manifest?.extensions && Array.isArray(manifest.extensions)) {
 					for (const extPath of manifest.extensions) {
 						const resolvedExtPath = resolve(entryPath, extPath);
-						if (ctx.fs.isFile(resolvedExtPath)) {
+						const content = await readFile(resolvedExtPath);
+						if (content !== null) {
 							discovered.push(resolvedExtPath);
 						}
 					}
@@ -365,12 +373,10 @@ export function discoverExtensionModulePaths(ctx: LoadContext, dir: string): str
 			}
 
 			// Check for index.ts or index.js
-			const indexTs = join(entryPath, "index.ts");
-			const indexJs = join(entryPath, "index.js");
-			if (ctx.fs.isFile(indexTs)) {
-				discovered.push(indexTs);
-			} else if (ctx.fs.isFile(indexJs)) {
-				discovered.push(indexJs);
+			if (subFileNames.has("index.ts")) {
+				discovered.push(join(entryPath, "index.ts"));
+			} else if (subFileNames.has("index.js")) {
+				discovered.push(join(entryPath, "index.js"));
 			}
 		}
 	}

package/src/discovery/index.ts

@@ -58,8 +58,7 @@ export {
 	isProviderEnabled,
 	listCapabilities,
 	// Loading API
-	load,
-	loadSync,
+	loadCapability,
 	// Cache management
 	reset,
 	setDisabledProviders,

package/src/discovery/mcp-json.ts

@@ -8,6 +8,7 @@
  */
 
 import { join } from "node:path";
+import { readFile } from "../capability/fs";
 import { registerProvider } from "../capability/index";
 import { type MCPServer, mcpCapability } from "../capability/mcp";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
@@ -69,17 +70,16 @@ function transformMCPConfig(config: MCPConfigFile, source: SourceMeta): MCPServe
 /**
  * Load MCP servers from a JSON file.
  */
-function loadMCPJsonFile(ctx: LoadContext, path: string, level: "user" | "project"): LoadResult<MCPServer> {
+async function loadMCPJsonFile(
+	_ctx: LoadContext,
+	path: string,
+	level: "user" | "project",
+): Promise<LoadResult<MCPServer>> {
 	const warnings: string[] = [];
 	const items: MCPServer[] = [];
 
-	if (!ctx.fs.isFile(path)) {
-		return { items, warnings };
-	}
-
-	const content = ctx.fs.readFile(path);
+	const content = await readFile(path);
 	if (content === null) {
-		warnings.push(`Failed to read ${path}`);
 		return { items, warnings };
 	}
 
@@ -99,17 +99,14 @@ function loadMCPJsonFile(ctx: LoadContext, path: string, level: "user" | "projec
 /**
  * MCP JSON Provider loader.
  */
-function load(ctx: LoadContext): LoadResult<MCPServer> {
-	const allItems: MCPServer[] = [];
-	const allWarnings: string[] = [];
-
-	// Check for mcp.json or .mcp.json in project root (cwd)
-	for (const filename of ["mcp.json", ".mcp.json"]) {
-		const path = join(ctx.cwd, filename);
-		const result = loadMCPJsonFile(ctx, path, "project");
-		allItems.push(...result.items);
-		if (result.warnings) allWarnings.push(...result.warnings);
-	}
+async function load(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
+	const filenames = ["mcp.json", ".mcp.json"];
+	const results = await Promise.all(
+		filenames.map((filename) => loadMCPJsonFile(ctx, join(ctx.cwd, filename), "project")),
+	);
+
+	const allItems = results.flatMap((r) => r.items);
+	const allWarnings = results.flatMap((r) => r.warnings ?? []);
 
 	return {
 		items: allItems,

package/src/discovery/ssh.ts

@@ -6,6 +6,7 @@
  */
 
 import { join } from "node:path";
+import { readFile } from "../capability/fs";
 import { registerProvider } from "../capability/index";
 import { type SSHHost, sshCapability } from "../capability/ssh";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
@@ -90,17 +91,12 @@ function normalizeHost(
 	};
 }
 
-function loadSshJsonFile(ctx: LoadContext, path: string): LoadResult<SSHHost> {
+async function loadSshJsonFile(_ctx: LoadContext, path: string): Promise<LoadResult<SSHHost>> {
 	const items: SSHHost[] = [];
 	const warnings: string[] = [];
 
-	if (!ctx.fs.isFile(path)) {
-		return { items, warnings };
-	}
-
-	const content = ctx.fs.readFile(path);
+	const content = await readFile(path);
 	if (content === null) {
-		warnings.push(`Failed to read ${path}`);
 		return { items, warnings };
 	}
 
@@ -126,7 +122,7 @@ function loadSshJsonFile(ctx: LoadContext, path: string): LoadResult<SSHHost> {
 			warnings.push(`Invalid host entry in ${path}: ${name}`);
 			continue;
 		}
-		const host = normalizeHost(name, rawHost, source, ctx.home, warnings);
+		const host = normalizeHost(name, rawHost, source, _ctx.home, warnings);
 		if (host) items.push(host);
 	}
 
@@ -136,16 +132,12 @@ function loadSshJsonFile(ctx: LoadContext, path: string): LoadResult<SSHHost> {
 	};
 }
 
-function load(ctx: LoadContext): LoadResult<SSHHost> {
-	const allItems: SSHHost[] = [];
-	const allWarnings: string[] = [];
+async function load(ctx: LoadContext): Promise<LoadResult<SSHHost>> {
+	const filenames = ["ssh.json", ".ssh.json"];
+	const results = await Promise.all(filenames.map((filename) => loadSshJsonFile(ctx, join(ctx.cwd, filename))));
 
-	for (const filename of ["ssh.json", ".ssh.json"]) {
-		const path = join(ctx.cwd, filename);
-		const result = loadSshJsonFile(ctx, path);
-		allItems.push(...result.items);
-		if (result.warnings) allWarnings.push(...result.warnings);
-	}
+	const allItems = results.flatMap((r) => r.items);
+	const allWarnings = results.flatMap((r) => r.warnings ?? []);
 
 	return {
 		items: allItems,

package/src/discovery/vscode.ts

@@ -5,6 +5,7 @@
  * Supports MCP server discovery from `mcp.json` with nested `mcp.servers` structure.
  */
 
+import { readFile } from "../capability/fs";
 import { registerProvider } from "../capability/index";
 import { type MCPServer, mcpCapability } from "../capability/mcp";
 import type { LoadContext, LoadResult } from "../capability/types";
@@ -23,14 +24,14 @@ registerProvider<MCPServer>(mcpCapability.id, {
 	displayName: DISPLAY_NAME,
 	description: "Load MCP servers from .vscode/mcp.json",
 	priority: PRIORITY,
-	load(ctx: LoadContext): LoadResult<MCPServer> {
+	async load(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
 		const items: MCPServer[] = [];
 		const warnings: string[] = [];
 
 		// Project-only (VS Code doesn't support user-level MCP config)
 		const projectPath = getProjectPath(ctx, "vscode", "mcp.json");
-		if (projectPath && ctx.fs.isFile(projectPath)) {
-			const result = loadMCPConfig(ctx, projectPath, "project");
+		if (projectPath) {
+			const result = await loadMCPConfig(ctx, projectPath, "project");
 			items.push(...result.items);
 			if (result.warnings) warnings.push(...result.warnings);
 		}
@@ -43,11 +44,15 @@ registerProvider<MCPServer>(mcpCapability.id, {
  * Load MCP servers from a mcp.json file.
  * VS Code uses nested structure: { "mcp": { "servers": { ... } } }
  */
-function loadMCPConfig(ctx: LoadContext, path: string, level: "user" | "project"): LoadResult<MCPServer> {
+async function loadMCPConfig(
+	_ctx: LoadContext,
+	path: string,
+	level: "user" | "project",
+): Promise<LoadResult<MCPServer>> {
 	const items: MCPServer[] = [];
 	const warnings: string[] = [];
 
-	const content = ctx.fs.readFile(path);
+	const content = await readFile(path);
 	if (!content) {
 		warnings.push(`Failed to read ${path}`);
 		return { items, warnings };

package/src/discovery/windsurf.ts

@@ -11,6 +11,7 @@
  * - Legacy .windsurfrules file
  */
 
+import { readFile } from "../capability/fs";
 import { registerProvider } from "../capability/index";
 import { type MCPServer, mcpCapability } from "../capability/mcp";
 import { type Rule, ruleCapability } from "../capability/rule";
@@ -33,65 +34,58 @@ const PRIORITY = 50;
 // MCP Servers
 // =============================================================================
 
-function loadMCPServers(ctx: LoadContext): LoadResult<MCPServer> {
+function parseServerConfig(
+	name: string,
+	serverConfig: unknown,
+	path: string,
+	scope: "user" | "project",
+): { server?: MCPServer; warning?: string } {
+	if (typeof serverConfig !== "object" || serverConfig === null) {
+		return { warning: `Invalid server config for "${name}" in ${path}` };
+	}
+
+	const server = expandEnvVarsDeep(serverConfig as Record<string, unknown>);
+	return {
+		server: {
+			name,
+			command: server.command as string | undefined,
+			args: server.args as string[] | undefined,
+			env: server.env as Record<string, string> | undefined,
+			url: server.url as string | undefined,
+			headers: server.headers as Record<string, string> | undefined,
+			transport: server.type as "stdio" | "sse" | "http" | undefined,
+			_source: createSourceMeta(PROVIDER_ID, path, scope),
+		},
+	};
+}
+
+async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
 	const items: MCPServer[] = [];
 	const warnings: string[] = [];
 
-	// User-level: ~/.codeium/windsurf/mcp_config.json
 	const userPath = getUserPath(ctx, "windsurf", "mcp_config.json");
-	if (userPath && ctx.fs.isFile(userPath)) {
-		const content = ctx.fs.readFile(userPath);
-		if (content) {
-			const config = parseJSON<{ mcpServers?: Record<string, unknown> }>(content);
-			if (config?.mcpServers) {
-				for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-					if (typeof serverConfig !== "object" || serverConfig === null) {
-						warnings.push(`Invalid server config for "${name}" in ${userPath}`);
-						continue;
-					}
-
-					const server = expandEnvVarsDeep(serverConfig as Record<string, unknown>);
-					items.push({
-						name,
-						command: server.command as string | undefined,
-						args: server.args as string[] | undefined,
-						env: server.env as Record<string, string> | undefined,
-						url: server.url as string | undefined,
-						headers: server.headers as Record<string, string> | undefined,
-						transport: server.type as "stdio" | "sse" | "http" | undefined,
-						_source: createSourceMeta(PROVIDER_ID, userPath, "user"),
-					});
-				}
-			}
-		}
-	}
+	const [userContent, projectPath] = await Promise.all([
+		userPath ? readFile(userPath) : Promise.resolve(null),
+		getProjectPath(ctx, "windsurf", "mcp_config.json"),
+	]);
 
-	// Project-level: .windsurf/mcp_config.json
-	const projectPath = getProjectPath(ctx, "windsurf", "mcp_config.json");
-	if (projectPath && ctx.fs.isFile(projectPath)) {
-		const content = ctx.fs.readFile(projectPath);
-		if (content) {
-			const config = parseJSON<{ mcpServers?: Record<string, unknown> }>(content);
-			if (config?.mcpServers) {
-				for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-					if (typeof serverConfig !== "object" || serverConfig === null) {
-						warnings.push(`Invalid server config for "${name}" in ${projectPath}`);
-						continue;
-					}
-
-					const server = expandEnvVarsDeep(serverConfig as Record<string, unknown>);
-					items.push({
-						name,
-						command: server.command as string | undefined,
-						args: server.args as string[] | undefined,
-						env: server.env as Record<string, string> | undefined,
-						url: server.url as string | undefined,
-						headers: server.headers as Record<string, string> | undefined,
-						transport: server.type as "stdio" | "sse" | "http" | undefined,
-						_source: createSourceMeta(PROVIDER_ID, projectPath, "project"),
-					});
-				}
-			}
+	const projectContent = projectPath ? await readFile(projectPath) : null;
+
+	const configs: Array<{ content: string | null; path: string | null; scope: "user" | "project" }> = [
+		{ content: userContent, path: userPath, scope: "user" },
+		{ content: projectContent, path: projectPath, scope: "project" },
+	];
+
+	for (const { content, path, scope } of configs) {
+		if (!content || !path) continue;
+
+		const config = parseJSON<{ mcpServers?: Record<string, unknown> }>(content);
+		if (!config?.mcpServers) continue;
+
+		for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+			const result = parseServerConfig(name, serverConfig, path, scope);
+			if (result.warning) warnings.push(result.warning);
+			if (result.server) items.push(result.server);
 		}
 	}
 
@@ -102,14 +96,14 @@ function loadMCPServers(ctx: LoadContext): LoadResult<MCPServer> {
 // Rules
 // =============================================================================
 
-function loadRules(ctx: LoadContext): LoadResult<Rule> {
+async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 	const items: Rule[] = [];
 	const warnings: string[] = [];
 
 	// User-level: ~/.codeium/windsurf/memories/global_rules.md
 	const userPath = getUserPath(ctx, "windsurf", "memories/global_rules.md");
-	if (userPath && ctx.fs.isFile(userPath)) {
-		const content = ctx.fs.readFile(userPath);
+	if (userPath) {
+		const content = await readFile(userPath);
 		if (content) {
 			const { frontmatter, body } = parseFrontmatter(content);
 
@@ -137,7 +131,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 	// Project-level: .windsurf/rules/*.md
 	const projectRulesDir = getProjectPath(ctx, "windsurf", "rules");
 	if (projectRulesDir) {
-		const result = loadFilesFromDir<Rule>(ctx, projectRulesDir, PROVIDER_ID, "project", {
+		const result = await loadFilesFromDir<Rule>(ctx, projectRulesDir, PROVIDER_ID, "project", {
 			extensions: ["md"],
 			transform: (name, content, path, source) => {
 				const { frontmatter, body } = parseFrontmatter(content);
@@ -167,34 +161,6 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 		if (result.warnings) warnings.push(...result.warnings);
 	}
 
-	// Legacy: .windsurfrules in project root
-	const legacyPath = ctx.fs.walkUp(".windsurfrules", { file: true });
-	if (legacyPath) {
-		const content = ctx.fs.readFile(legacyPath);
-		if (content) {
-			const { frontmatter, body } = parseFrontmatter(content);
-
-			// Validate and normalize globs
-			let globs: string[] | undefined;
-			if (Array.isArray(frontmatter.globs)) {
-				globs = frontmatter.globs.filter((g): g is string => typeof g === "string");
-			} else if (typeof frontmatter.globs === "string") {
-				globs = [frontmatter.globs];
-			}
-
-			items.push({
-				name: "windsurfrules",
-				path: legacyPath,
-				content: body,
-				globs,
-				alwaysApply: frontmatter.alwaysApply as boolean | undefined,
-				description: frontmatter.description as string | undefined,
-				ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
-				_source: createSourceMeta(PROVIDER_ID, legacyPath, "project"),
-			});
-		}
-	}
-
 	return { items, warnings };
 }
 

package/src/main.ts

@@ -359,6 +359,10 @@ async function buildSessionOptions(
 		options.toolNames = parsed.tools;
 	}
 
+	if (parsed.noLsp) {
+		options.enableLsp = false;
+	}
+
 	// Skills
 	if (parsed.noSkills) {
 		options.skills = [];
@@ -461,7 +465,7 @@ export async function main(args: string[]) {
 	}
 
 	const cwd = process.cwd();
-	const settingsManager = SettingsManager.create(cwd);
+	const settingsManager = await SettingsManager.create(cwd);
 	settingsManager.applyEnvironmentVariables();
 	time("SettingsManager.create");
 	const { initialMessage, initialImages } = await prepareInitialMessage(parsed, settingsManager.getImageAutoResize());