@dreki-gg/pi-subagent 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @dreki-gg/pi-subagent
 
+## 0.5.0
+
+### Minor Changes
+
+- [`4f2f148`](https://github.com/dreki-gg/pi-extensions/commit/4f2f148488e32ff43f97216a5c221fd9d1716a11) Thanks [@jalbarrang](https://github.com/jalbarrang)! - added agents to the registry so my fork is able to discover subagent files
+
 ## 0.4.0
 
 ### Minor Changes

package/extensions/subagent/agents.ts

@@ -1,13 +1,21 @@
 /**
  * Agent discovery and configuration
+ *
+ * Supports two discovery strategies:
+ * 1. Package-resolved: Uses pi's ResolvedPaths.agents from the package manager
+ *    when available (pi forks with first-class agents resource support).
+ *    Package agents are resolved, filtered, and toggleable via pi config.
+ * 2. Legacy: Manual filesystem discovery from bundled, user, and project dirs.
+ *    Used as fallback when ResolvedPaths.agents is not available.
  */
 
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { getAgentDir, parseFrontmatter } from '@mariozechner/pi-coding-agent';
+import type { ResolvedPaths } from '@mariozechner/pi-coding-agent';
 
 export type AgentScope = 'user' | 'project' | 'both';
-export type AgentSource = 'bundled' | 'user' | 'project';
+export type AgentSource = 'bundled' | 'user' | 'project' | 'package';
 
 export interface AgentConfig {
   name: string;
@@ -100,6 +108,56 @@ function findNearestProjectAgentsDir(cwd: string): string | null {
   }
 }
 
+/**
+ * Load agents from package-manager resolved paths (enabled only).
+ * This is called with pre-resolved paths from an async context.
+ */
+export function loadAgentsFromResolvedPaths(resolvedPaths: ResolvedPaths): AgentConfig[] {
+  // Check if the agents field exists (compatibility with upstream pi)
+  const agentResources = (resolvedPaths as unknown as Record<string, unknown>).agents;
+  if (!agentResources || !Array.isArray(agentResources)) {
+    return [];
+  }
+
+  const agents: AgentConfig[] = [];
+  for (const resource of agentResources) {
+    if (!resource.enabled) continue;
+    const agent = loadAgentFromFile(resource.path, 'package');
+    if (agent) agents.push(agent);
+  }
+  return agents;
+}
+
+function loadAgentFromFile(filePath: string, source: AgentSource): AgentConfig | null {
+  let content: string;
+  try {
+    content = fs.readFileSync(filePath, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  const { frontmatter, body } = parseFrontmatter<Record<string, string>>(content);
+  if (!frontmatter.name || !frontmatter.description) {
+    return null;
+  }
+
+  const tools = frontmatter.tools
+    ?.split(',')
+    .map((t: string) => t.trim())
+    .filter(Boolean);
+
+  return {
+    name: frontmatter.name,
+    description: frontmatter.description,
+    tools: tools && tools.length > 0 ? tools : undefined,
+    model: frontmatter.model,
+    thinking: frontmatter.thinking,
+    systemPrompt: body,
+    source,
+    filePath,
+  };
+}
+
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
   const userDir = path.join(getAgentDir(), 'agents');
   const projectAgentsDir = findNearestProjectAgentsDir(cwd);
@@ -128,6 +186,34 @@ export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryRe
   return { agents: Array.from(agentMap.values()), projectAgentsDir };
 }
 
+/**
+ * Discover agents with package-resolved paths merged in.
+ * Package-resolved agents (from pi.agents in installed packages) are loaded
+ * at lowest priority, then overridden by bundled, user, and project agents.
+ *
+ * Falls back to discoverAgents() when resolvedPaths is not provided or
+ * does not contain the agents field (upstream pi compatibility).
+ */
+export function discoverAgentsWithPackages(
+  cwd: string,
+  scope: AgentScope,
+  resolvedPaths?: ResolvedPaths,
+): AgentDiscoveryResult {
+  const base = discoverAgents(cwd, scope);
+
+  if (!resolvedPaths) return base;
+
+  const packageAgents = loadAgentsFromResolvedPaths(resolvedPaths);
+  if (packageAgents.length === 0) return base;
+
+  // Package agents are lowest priority: existing agents override by name
+  const agentMap = new Map<string, AgentConfig>();
+  for (const agent of packageAgents) agentMap.set(agent.name, agent);
+  for (const agent of base.agents) agentMap.set(agent.name, agent);
+
+  return { agents: Array.from(agentMap.values()), projectAgentsDir: base.projectAgentsDir };
+}
+
 export { bundledAgentsDir };
 
 export function formatAgentList(

package/extensions/subagent/delegate-executor.ts

@@ -3,8 +3,9 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { withFileMutationQueue } from '@mariozechner/pi-coding-agent';
+import type { ResolvedPaths } from '@mariozechner/pi-coding-agent';
 import type { Message } from '@mariozechner/pi-ai';
-import { discoverAgents, type AgentScope } from './agents';
+import { discoverAgentsWithPackages, type AgentScope } from './agents';
 import type { AgentResult, UsageStats } from './delegate-types';
 
 function emptyUsage(): UsageStats {
@@ -45,6 +46,7 @@ export interface RunAgentOptions {
   onUpdate?: OnPhaseUpdate;
   phaseName?: string;
   signal?: AbortSignal;
+  resolvedPaths?: ResolvedPaths;
 }
 
 export async function runAgent(
@@ -53,7 +55,7 @@ export async function runAgent(
   task: string,
   options: RunAgentOptions = {},
 ): Promise<AgentResult> {
-  const { agents } = discoverAgents(cwd, options.agentScope ?? 'user');
+  const { agents } = discoverAgentsWithPackages(cwd, options.agentScope ?? 'user', options.resolvedPaths);
   const agent = agents.find((a) => a.name === agentName);
 
   if (!agent) {

package/extensions/subagent/index.ts

@@ -25,10 +25,13 @@ import { StringEnum } from '@mariozechner/pi-ai';
 import {
   type ExtensionAPI,
   type ExtensionCommandContext,
+  DefaultPackageManager,
   getAgentDir,
   getMarkdownTheme,
+  SettingsManager,
   withFileMutationQueue,
 } from '@mariozechner/pi-coding-agent';
+import type { ResolvedPaths } from '@mariozechner/pi-coding-agent';
 import { Container, Markdown, Spacer, Text } from '@mariozechner/pi-tui';
 import { Type } from '@sinclair/typebox';
 import {
@@ -37,6 +40,7 @@ import {
   type AgentSource,
   bundledAgentsDir,
   discoverAgents,
+  discoverAgentsWithPackages,
 } from './agents.js';
 import { formatDelegateUsage, parseDelegateArgs } from './delegate-args.js';
 import { runAgent, runParallel } from './delegate-executor.js';
@@ -507,6 +511,26 @@ const SubagentParams = Type.Object({
   ),
 });
 
+/**
+ * Try to resolve package paths including the agents resource.
+ * Returns null if the pi version does not support ResolvedPaths.agents.
+ */
+async function tryResolvePackagePaths(cwd: string): Promise<ResolvedPaths | undefined> {
+  try {
+    const agentDir = getAgentDir();
+    const settingsManager = SettingsManager.create(cwd, agentDir);
+    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
+    const resolved = await packageManager.resolve();
+    // Check if this pi version has agents support
+    if ('agents' in resolved && Array.isArray((resolved as Record<string, unknown>).agents)) {
+      return resolved;
+    }
+  } catch {
+    // Incompatible pi version or missing API
+  }
+  return undefined;
+}
+
 export default function (pi: ExtensionAPI) {
   pi.registerTool({
     name: 'subagent',
@@ -521,7 +545,8 @@ export default function (pi: ExtensionAPI) {
 
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const agentScope: AgentScope = params.agentScope ?? 'user';
-      const discovery = discoverAgents(ctx.cwd, agentScope);
+      const resolvedPaths = await tryResolvePackagePaths(ctx.cwd);
+      const discovery = discoverAgentsWithPackages(ctx.cwd, agentScope, resolvedPaths);
       const agents = discovery.agents;
       const confirmProjectAgents = params.confirmProjectAgents ?? true;
 
@@ -1142,6 +1167,7 @@ export default function (pi: ExtensionAPI) {
     previousOutput: string,
     ctx: ExtensionCommandContext,
     agentScope: AgentScope,
+    resolvedPaths?: ResolvedPaths,
   ): Promise<{ results: AgentResult[]; output: string; aborted: boolean }> {
     const task = phase.taskTemplate
       .replace(/\{synthesis\}/g, synthesis)
@@ -1160,11 +1186,13 @@ export default function (pi: ExtensionAPI) {
           // Streaming updates happen per-message
         },
         phaseName: phase.name,
+        resolvedPaths,
       });
     } else {
       const result = await runAgent(cwd, phase.agents[0], task, {
         agentScope,
         phaseName: phase.name,
+        resolvedPaths,
       });
       results = [result];
     }
@@ -1311,6 +1339,7 @@ export default function (pi: ExtensionAPI) {
       }
 
       const { explicitTask, agentScope, workflowId, confirmProjectAgents } = parsed.options;
+      const resolvedPaths = await tryResolvePackagePaths(ctx.cwd);
 
       // Step 1: Synthesize
       const conversation = extractRecentConversation(ctx);
@@ -1322,7 +1351,7 @@ export default function (pi: ExtensionAPI) {
       const prompt = buildSynthesisPrompt(conversation, explicitTask);
       ctx.ui.notify('⏳ Synthesizing task from conversation...', 'info');
 
-      const synthResult = await runAgent(ctx.cwd, 'planner', prompt, { agentScope });
+      const synthResult = await runAgent(ctx.cwd, 'planner', prompt, { agentScope, resolvedPaths });
       const synthesis = getFinalText(synthResult);
 
       if (!synthesis.trim()) {
@@ -1351,7 +1380,7 @@ export default function (pi: ExtensionAPI) {
       }
 
       if ((agentScope === 'project' || agentScope === 'both') && confirmProjectAgents && ctx.hasUI) {
-        const discovery = discoverAgents(ctx.cwd, agentScope);
+        const discovery = discoverAgentsWithPackages(ctx.cwd, agentScope, resolvedPaths);
         const requestedProjectAgents = workflow.phases
           .flatMap((phase) => phase.agents)
           .map((name) => discovery.agents.find((agent) => agent.name === name))
@@ -1391,6 +1420,7 @@ export default function (pi: ExtensionAPI) {
           previousOutput,
           ctx,
           agentScope,
+          resolvedPaths,
         );
 
         const phase: PhaseResult = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreki-gg/pi-subagent",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Subagent tool and delegate orchestration for pi — isolated agents, parallel scouts, planning gates, and workflow presets",
   "keywords": [
     "pi-package"
@@ -28,6 +28,9 @@
     ],
     "prompts": [
       "./prompts"
+    ],
+    "agents": [
+      "./agents"
     ]
   },
   "devDependencies": {