@oh-my-pi/pi-coding-agent 13.7.6 → 13.9.1

package/src/discovery/agents.ts

@@ -1,7 +1,9 @@
 /**
  * Agents (standard) Provider
  *
- * Loads user-level skills, rules, prompts, commands, context files, and system prompts from ~/.agent/.
+ * Loads skills, rules, prompts, commands, context files, and system prompts
+ * from .agent/ and .agents/ directories at both user (~/) and project levels.
+ * Project-level discovery walks up from cwd to repoRoot.
  */
 import * as path from "node:path";
 import { registerProvider } from "../capability";
@@ -13,76 +15,97 @@ import { type Skill, skillCapability } from "../capability/skill";
 import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
 import { type SystemPrompt, systemPromptCapability } from "../capability/system-prompt";
 import type { LoadContext, LoadResult } from "../capability/types";
-import { buildRuleFromMarkdown, createSourceMeta, loadFilesFromDir, scanSkillsFromDir } from "./helpers";
+import {
+	buildRuleFromMarkdown,
+	calculateDepth,
+	createSourceMeta,
+	loadFilesFromDir,
+	scanSkillsFromDir,
+} from "./helpers";
 
 const PROVIDER_ID = "agents";
 const DISPLAY_NAME = "Agents (standard)";
 const PRIORITY = 70;
-const USER_AGENT_DIR_CANDIDATES = [".agent", ".agents"] as const;
+const AGENT_DIR_CANDIDATES = [".agent", ".agents"] as const;
 
-function getUserAgentPathCandidates(ctx: LoadContext, ...segments: string[]): string[] {
-	return USER_AGENT_DIR_CANDIDATES.map(baseDir => path.join(ctx.home, baseDir, ...segments));
+/** User-level paths: ~/.agent/<segments> and ~/.agents/<segments>. */
+function getUserPathCandidates(ctx: LoadContext, ...segments: string[]): string[] {
+	return AGENT_DIR_CANDIDATES.map(baseDir => path.join(ctx.home, baseDir, ...segments));
 }
 
-async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
-	const items: Skill[] = [];
-	const warnings: string[] = [];
-	for (const userSkillsDir of getUserAgentPathCandidates(ctx, "skills")) {
-		const result = await scanSkillsFromDir(ctx, {
-			dir: userSkillsDir,
-			providerId: PROVIDER_ID,
-			level: "user",
-		});
-		items.push(...result.items);
-		warnings.push(...(result.warnings ?? []));
+/** Project-level paths: walk up from cwd to repoRoot, returning .agent/<segments> and .agents/<segments> at each level. */
+function getProjectPathCandidates(ctx: LoadContext, ...segments: string[]): string[] {
+	const paths: string[] = [];
+	let current = ctx.cwd;
+	while (true) {
+		for (const baseDir of AGENT_DIR_CANDIDATES) {
+			paths.push(path.join(current, baseDir, ...segments));
+		}
+		if (current === (ctx.repoRoot ?? ctx.home)) break;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
 	}
+	return paths;
+}
+
+// Skills
+async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
+	const projectScans = getProjectPathCandidates(ctx, "skills").map(dir =>
+		scanSkillsFromDir(ctx, { dir, providerId: PROVIDER_ID, level: "project" }),
+	);
+	const userScans = getUserPathCandidates(ctx, "skills").map(dir =>
+		scanSkillsFromDir(ctx, { dir, providerId: PROVIDER_ID, level: "user" }),
+	);
+
+	const results = await Promise.all([...projectScans, ...userScans]);
+
 	return {
-		items,
-		warnings,
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
 	};
 }
 
 registerProvider<Skill>(skillCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load skills from ~/.agent/skills (fallback ~/.agents/skills)",
+	description: "Load skills from .agent/skills and .agents/skills (project walk-up + user home)",
 	priority: PRIORITY,
 	load: loadSkills,
 });
 
 // Rules
 async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
-	const items: Rule[] = [];
-	const warnings: string[] = [];
-	for (const userRulesDir of getUserAgentPathCandidates(ctx, "rules")) {
-		const result = await loadFilesFromDir<Rule>(ctx, userRulesDir, PROVIDER_ID, "user", {
+	const load = (dir: string, level: "user" | "project") =>
+		loadFilesFromDir<Rule>(ctx, dir, PROVIDER_ID, level, {
 			extensions: ["md", "mdc"],
 			transform: (name, content, filePath, source) =>
 				buildRuleFromMarkdown(name, content, filePath, source, { stripNamePattern: /\.(md|mdc)$/ }),
 		});
-		items.push(...result.items);
-		warnings.push(...(result.warnings ?? []));
-	}
+
+	const results = await Promise.all([
+		...getProjectPathCandidates(ctx, "rules").map(dir => load(dir, "project")),
+		...getUserPathCandidates(ctx, "rules").map(dir => load(dir, "user")),
+	]);
+
 	return {
-		items,
-		warnings,
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
 	};
 }
 
 registerProvider<Rule>(ruleCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load rules from ~/.agent/rules (fallback ~/.agents/rules)",
+	description: "Load rules from .agent/rules and .agents/rules (project walk-up + user home)",
 	priority: PRIORITY,
 	load: loadRules,
 });
 
 // Prompts
 async function loadPrompts(ctx: LoadContext): Promise<LoadResult<Prompt>> {
-	const items: Prompt[] = [];
-	const warnings: string[] = [];
-	for (const userPromptsDir of getUserAgentPathCandidates(ctx, "prompts")) {
-		const result = await loadFilesFromDir<Prompt>(ctx, userPromptsDir, PROVIDER_ID, "user", {
+	const load = (dir: string, level: "user" | "project") =>
+		loadFilesFromDir<Prompt>(ctx, dir, PROVIDER_ID, level, {
 			extensions: ["md"],
 			transform: (name, content, filePath, source) => ({
 				name: name.replace(/\.md$/, ""),
@@ -91,109 +114,106 @@ async function loadPrompts(ctx: LoadContext): Promise<LoadResult<Prompt>> {
 				_source: source,
 			}),
 		});
-		items.push(...result.items);
-		warnings.push(...(result.warnings ?? []));
-	}
+
+	const results = await Promise.all([
+		...getProjectPathCandidates(ctx, "prompts").map(dir => load(dir, "project")),
+		...getUserPathCandidates(ctx, "prompts").map(dir => load(dir, "user")),
+	]);
+
 	return {
-		items,
-		warnings,
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
 	};
 }
 
 registerProvider<Prompt>(promptCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load prompts from ~/.agent/prompts (fallback ~/.agents/prompts)",
+	description: "Load prompts from .agent/prompts and .agents/prompts (project walk-up + user home)",
 	priority: PRIORITY,
 	load: loadPrompts,
 });
 
 // Slash Commands
 async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
-	const items: SlashCommand[] = [];
-	const warnings: string[] = [];
-	for (const userCommandsDir of getUserAgentPathCandidates(ctx, "commands")) {
-		const result = await loadFilesFromDir<SlashCommand>(ctx, userCommandsDir, PROVIDER_ID, "user", {
+	const load = (dir: string, level: "user" | "project") =>
+		loadFilesFromDir<SlashCommand>(ctx, dir, PROVIDER_ID, level, {
 			extensions: ["md"],
 			transform: (name, content, filePath, source) => ({
 				name: name.replace(/\.md$/, ""),
 				path: filePath,
 				content,
-				level: "user",
+				level,
 				_source: source,
 			}),
 		});
-		items.push(...result.items);
-		warnings.push(...(result.warnings ?? []));
-	}
+
+	const results = await Promise.all([
+		...getProjectPathCandidates(ctx, "commands").map(dir => load(dir, "project")),
+		...getUserPathCandidates(ctx, "commands").map(dir => load(dir, "user")),
+	]);
+
 	return {
-		items,
-		warnings,
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
 	};
 }
 
 registerProvider<SlashCommand>(slashCommandCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load commands from ~/.agent/commands (fallback ~/.agents/commands)",
+	description: "Load commands from .agent/commands and .agents/commands (project walk-up + user home)",
 	priority: PRIORITY,
 	load: loadSlashCommands,
 });
 
 // Context Files (AGENTS.md)
 async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFile>> {
-	const items: ContextFile[] = [];
-	for (const agentsPath of getUserAgentPathCandidates(ctx, "AGENTS.md")) {
-		const content = await readFile(agentsPath);
-		if (!content) {
-			continue;
-		}
-		items.push({
-			path: agentsPath,
-			content,
-			level: "user",
-			_source: createSourceMeta(PROVIDER_ID, agentsPath, "user"),
-		});
-	}
-	return {
-		items,
-		warnings: [],
+	const load = async (filePath: string, level: "user" | "project"): Promise<ContextFile | null> => {
+		const content = await readFile(filePath);
+		if (!content) return null;
+		// filePath is <ancestor>/.agent(s)/AGENTS.md — go up past the config dir to the ancestor
+		const ancestorDir = path.dirname(path.dirname(filePath));
+		const depth = level === "project" ? calculateDepth(ctx.cwd, ancestorDir, path.sep) : undefined;
+		return { path: filePath, content, level, depth, _source: createSourceMeta(PROVIDER_ID, filePath, level) };
 	};
+
+	const results = await Promise.all([
+		...getProjectPathCandidates(ctx, "AGENTS.md").map(p => load(p, "project")),
+		...getUserPathCandidates(ctx, "AGENTS.md").map(p => load(p, "user")),
+	]);
+
+	return { items: results.filter((r): r is ContextFile => r !== null), warnings: [] };
 }
 
 registerProvider<ContextFile>(contextFileCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load AGENTS.md from ~/.agent (fallback ~/.agents)",
+	description: "Load AGENTS.md from .agent and .agents (project walk-up + user home)",
 	priority: PRIORITY,
 	load: loadContextFiles,
 });
 
 // System Prompt (SYSTEM.md)
 async function loadSystemPrompt(ctx: LoadContext): Promise<LoadResult<SystemPrompt>> {
-	const items: SystemPrompt[] = [];
-	for (const systemPath of getUserAgentPathCandidates(ctx, "SYSTEM.md")) {
-		const content = await readFile(systemPath);
-		if (!content) {
-			continue;
-		}
-		items.push({
-			path: systemPath,
-			content,
-			level: "user",
-			_source: createSourceMeta(PROVIDER_ID, systemPath, "user"),
-		});
-	}
-	return {
-		items,
-		warnings: [],
+	const load = async (filePath: string, level: "user" | "project"): Promise<SystemPrompt | null> => {
+		const content = await readFile(filePath);
+		if (!content) return null;
+		return { path: filePath, content, level, _source: createSourceMeta(PROVIDER_ID, filePath, level) };
 	};
+
+	const results = await Promise.all([
+		...getProjectPathCandidates(ctx, "SYSTEM.md").map(p => load(p, "project")),
+		...getUserPathCandidates(ctx, "SYSTEM.md").map(p => load(p, "user")),
+	]);
+
+	return { items: results.filter((r): r is SystemPrompt => r !== null), warnings: [] };
 }
 
 registerProvider<SystemPrompt>(systemPromptCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load SYSTEM.md from ~/.agent (fallback ~/.agents)",
+	description: "Load SYSTEM.md from .agent and .agents (project walk-up + user home)",
 	priority: PRIORITY,
 	load: loadSystemPrompt,
 });

package/src/discovery/builtin.ts

@@ -68,12 +68,13 @@ async function getConfigDirs(ctx: LoadContext): Promise<Array<{ dir: string; lev
 	return result;
 }
 
-function getAncestorDirs(cwd: string): Array<{ dir: string; depth: number }> {
+function getAncestorDirs(cwd: string, stopAt?: string | null): Array<{ dir: string; depth: number }> {
 	const ancestors: Array<{ dir: string; depth: number }> = [];
 	let current = cwd;
 	let depth = 0;
 	while (true) {
 		ancestors.push({ dir: current, depth });
+		if (stopAt && current === stopAt) break;
 		const parent = path.dirname(current);
 		if (parent === current) break;
 		current = parent;
@@ -82,8 +83,11 @@ function getAncestorDirs(cwd: string): Array<{ dir: string; depth: number }> {
 	return ancestors;
 }
 
-async function findNearestProjectConfigDir(cwd: string): Promise<{ dir: string; depth: number } | null> {
-	for (const ancestor of getAncestorDirs(cwd)) {
+async function findNearestProjectConfigDir(
+	cwd: string,
+	repoRoot?: string | null,
+): Promise<{ dir: string; depth: number } | null> {
+	for (const ancestor of getAncestorDirs(cwd, repoRoot)) {
 		const configDir = await ifNonEmptyDir(ancestor.dir, PATHS.projectDir);
 		if (configDir) return { dir: configDir, depth: ancestor.depth };
 	}
@@ -215,7 +219,7 @@ async function loadSystemPrompt(ctx: LoadContext): Promise<LoadResult<SystemProm
 		});
 	}
 
-	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd);
+	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd, ctx.repoRoot);
 	if (nearestProjectConfigDir) {
 		const projectPath = path.join(nearestProjectConfigDir.dir, "SYSTEM.md");
 		const projectContent = await readFile(projectPath);
@@ -242,18 +246,27 @@ registerProvider<SystemPrompt>(systemPromptCapability.id, {
 
 // Skills
 async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
-	const configDirs = await getConfigDirs(ctx);
-	const results = await Promise.all(
-		configDirs.map(({ dir, level }) =>
-			scanSkillsFromDir(ctx, {
-				dir: path.join(dir, "skills"),
-				providerId: PROVIDER_ID,
-				level,
-				requireDescription: true,
-			}),
-		),
+	// Walk up from cwd finding .omp/skills/ in ancestors (closest first)
+	const ancestors = getAncestorDirs(ctx.cwd, ctx.repoRoot ?? ctx.home);
+	const projectScans = ancestors.map(({ dir }) =>
+		scanSkillsFromDir(ctx, {
+			dir: path.join(dir, PATHS.projectDir, "skills"),
+			providerId: PROVIDER_ID,
+			level: "project",
+			requireDescription: true,
+		}),
 	);
 
+	// User-level scan from ~/.omp/agent/skills/
+	const userScan = scanSkillsFromDir(ctx, {
+		dir: path.join(ctx.home, PATHS.userAgent, "skills"),
+		providerId: PROVIDER_ID,
+		level: "user",
+		requireDescription: true,
+	});
+
+	const results = await Promise.all([...projectScans, userScan]);
+
 	return {
 		items: results.flatMap(r => r.items),
 		warnings: results.flatMap(r => r.warnings ?? []),
@@ -795,7 +808,7 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 		});
 	}
 
-	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd);
+	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd, ctx.repoRoot);
 	if (nearestProjectConfigDir) {
 		const projectPath = path.join(nearestProjectConfigDir.dir, "AGENTS.md");
 		const projectContent = await readFile(projectPath);

package/src/discovery/claude.ts

@@ -145,7 +145,7 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 	const projectClaudeMd = path.join(projectBase, "CLAUDE.md");
 	const projectContent = await readFile(projectClaudeMd);
 	if (projectContent !== null) {
-		const depth = calculateDepth(ctx.cwd, projectBase, path.sep);
+		const depth = calculateDepth(ctx.cwd, path.dirname(projectBase), path.sep);
 		items.push({
 			path: projectClaudeMd,
 			content: projectContent,
@@ -164,11 +164,27 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 
 async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 	const userSkillsDir = path.join(getUserClaude(ctx), "skills");
-	const projectSkillsDir = path.join(getProjectClaude(ctx), "skills");
 
-	const [userResult, projectResult] = await Promise.allSettled([
+	// Walk up from cwd finding .claude/skills/ in ancestors
+	const projectScans: Promise<LoadResult<Skill>>[] = [];
+	let current = ctx.cwd;
+	while (true) {
+		projectScans.push(
+			scanSkillsFromDir(ctx, {
+				dir: path.join(current, CONFIG_DIR, "skills"),
+				providerId: PROVIDER_ID,
+				level: "project",
+			}),
+		);
+		if (current === (ctx.repoRoot ?? ctx.home)) break;
+		const parent = path.dirname(current);
+		if (parent === current) break; // filesystem root
+		current = parent;
+	}
+
+	const [userResult, ...projectResults] = await Promise.allSettled([
 		scanSkillsFromDir(ctx, { dir: userSkillsDir, providerId: PROVIDER_ID, level: "user" }),
-		scanSkillsFromDir(ctx, { dir: projectSkillsDir, providerId: PROVIDER_ID, level: "project" }),
+		...projectScans,
 	]);
 
 	const items: Skill[] = [];
@@ -181,11 +197,13 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 		warnings.push(`Failed to scan Claude user skills in ${userSkillsDir}: ${String(userResult.reason)}`);
 	}
 
-	if (projectResult.status === "fulfilled") {
-		items.push(...projectResult.value.items);
-		warnings.push(...(projectResult.value.warnings ?? []));
-	} else if (!isMissingDirectoryError(projectResult.reason)) {
-		warnings.push(`Failed to scan Claude project skills in ${projectSkillsDir}: ${String(projectResult.reason)}`);
+	for (const projectResult of projectResults) {
+		if (projectResult.status === "fulfilled") {
+			items.push(...projectResult.value.items);
+			warnings.push(...(projectResult.value.warnings ?? []));
+		} else if (!isMissingDirectoryError(projectResult.reason)) {
+			warnings.push(`Failed to scan Claude project skills: ${String(projectResult.reason)}`);
+		}
 	}
 
 	return { items, warnings };

package/src/discovery/helpers.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { ThinkingLevel } from "@oh-my-pi/pi-ai";
+import { parseThinkingLevel } from "@oh-my-pi/pi-ai";
 import { FileType, glob } from "@oh-my-pi/pi-natives";
 import { CONFIG_DIR_NAME, tryParseJson } from "@oh-my-pi/pi-utils";
 import { readFile } from "../capability/fs";
@@ -9,8 +10,6 @@ import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 import { parseFrontmatter } from "../utils/frontmatter";
 
-const VALID_THINKING_LEVELS: readonly string[] = ["off", "minimal", "low", "medium", "high", "xhigh"];
-
 /**
  * Standard paths for each config source.
  */
@@ -100,18 +99,6 @@ export function createSourceMeta(provider: string, filePath: string, level: "use
 	};
 }
 
-/**
- * Parse thinking level from frontmatter.
- * Supports keys: thinkingLevel, thinking-level, thinking
- */
-export function parseThinkingLevel(frontmatter: Record<string, unknown>): ThinkingLevel | undefined {
-	const raw = frontmatter.thinkingLevel ?? frontmatter["thinking-level"] ?? frontmatter.thinking;
-	if (typeof raw === "string" && VALID_THINKING_LEVELS.includes(raw)) {
-		return raw as ThinkingLevel;
-	}
-	return undefined;
-}
-
 export function parseBoolean(value: unknown): boolean | undefined {
 	if (typeof value === "boolean") return value;
 	if (typeof value === "string") {
@@ -247,10 +234,16 @@ export function parseAgentFields(frontmatter: Record<string, unknown>): ParsedAg
 	}
 
 	const output = frontmatter.output !== undefined ? frontmatter.output : undefined;
+	const rawThinkingLevel =
+		typeof frontmatter.thinkingLevel === "string"
+			? frontmatter.thinkingLevel
+			: typeof frontmatter.thinking === "string"
+				? frontmatter.thinking
+				: undefined;
+
+	const thinkingLevel = parseThinkingLevel(rawThinkingLevel);
 	const model = parseModelList(frontmatter.model);
-	const thinkingLevel = parseThinkingLevel(frontmatter);
 	const blocking = parseBoolean(frontmatter.blocking);
-
 	return { name, description, tools, spawns, model, output, thinkingLevel, blocking };
 }
 

package/src/extensibility/extensions/loader.ts

@@ -4,8 +4,7 @@
 import type * as fs1 from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent, Model, TextContent } from "@oh-my-pi/pi-ai";
+import type { ImageContent, Model, TextContent, ThinkingLevel } from "@oh-my-pi/pi-ai";
 import * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import { hasFsCode, isEacces, isEnoent, logger } from "@oh-my-pi/pi-utils";

package/src/extensibility/extensions/types.ts

@@ -7,7 +7,7 @@
  * - Register commands, keyboard shortcuts, and CLI flags
  * - Interact with the user via UI primitives
  */
-import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type {
 	Api,
 	AssistantMessageEvent,
@@ -19,6 +19,7 @@ import type {
 	OAuthLoginCallbacks,
 	SimpleStreamOptions,
 	TextContent,
+	ThinkingLevel,
 	ToolResultMessage,
 } from "@oh-my-pi/pi-ai";
 import type * as piCodingAgent from "@oh-my-pi/pi-coding-agent";

package/src/extensibility/skills.ts

@@ -40,7 +40,7 @@ export async function loadSkillsFromDir(options: LoadSkillsFromDirOptions): Prom
 	const providerId = rawProviderId || "custom";
 	const level: "user" | "project" = rawLevel === "project" ? "project" : "user";
 	const result = await scanSkillsFromDir(
-		{ cwd: getProjectDir(), home: os.homedir() },
+		{ cwd: getProjectDir(), home: os.homedir(), repoRoot: null },
 		{
 			dir: options.dir,
 			providerId,
@@ -175,7 +175,7 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 		customDirectories.map(async dir => {
 			const expandedDir = expandTilde(dir);
 			const scanResult = await scanSkillsFromDir(
-				{ cwd, home: os.homedir() },
+				{ cwd, home: os.homedir(), repoRoot: null },
 				{
 					dir: expandedDir,
 					providerId: "custom",