@esso0428/pi-subagents 0.15.0 → 0.15.2

package/dist/agent-types.js

@@ -1,12 +1,30 @@
+"use strict";
 /**
  * agent-types.ts — Unified agent type registry.
  *
  * Merges embedded default agents with user-defined agents from .pi/agents/*.md, .agents/agents/*.md, and global agents.
  * User agents override defaults with the same name. Disabled agents are kept but excluded from spawning.
  */
-import { createCodingTools, createReadOnlyTools } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_AGENTS } from "./default-agents.js";
-import { applyNicoOverridesToMap, readNicoAgentOverrides } from "./nico-overrides.js";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_TOOL_NAMES = void 0;
+exports.isDefaultsDisabled = isDefaultsDisabled;
+exports.setDefaultsDisabled = setDefaultsDisabled;
+exports.registerAgents = registerAgents;
+exports.applyNicoOverrides = applyNicoOverrides;
+exports.resolveType = resolveType;
+exports.getAgentConfig = getAgentConfig;
+exports.getAvailableTypes = getAvailableTypes;
+exports.getAllTypes = getAllTypes;
+exports.getDefaultAgentNames = getDefaultAgentNames;
+exports.getUserAgentNames = getUserAgentNames;
+exports.isValidType = isValidType;
+exports.getMemoryToolNames = getMemoryToolNames;
+exports.getReadOnlyMemoryToolNames = getReadOnlyMemoryToolNames;
+exports.getToolNamesForType = getToolNamesForType;
+exports.getConfig = getConfig;
+const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
+const default_agents_js_1 = require("./default-agents.js");
+const nico_overrides_js_1 = require("./nico-overrides.js");
 /**
  * All known built-in tool names, derived from pi's own tool factories rather
  * than hardcoded so the set tracks pi-mono if it adds/renames a built-in.
@@ -15,27 +33,27 @@ import { applyNicoOverridesToMap, readNicoAgentOverrides } from "./nico-override
  * (read, bash, edit, write, grep, find, ls). The `cwd` only binds tool
  * operations we never invoke here — we read each tool's `.name` and discard it.
  */
-export const BUILTIN_TOOL_NAMES = [
-    ...new Set([...createCodingTools("."), ...createReadOnlyTools(".")].map((t) => t.name)),
+exports.BUILTIN_TOOL_NAMES = [
+    ...new Set([...(0, pi_coding_agent_1.createCodingTools)("."), ...(0, pi_coding_agent_1.createReadOnlyTools)(".")].map((t) => t.name)),
 ];
 /** Unified runtime registry of all agents (defaults + user-defined). */
 const agents = new Map();
 /** When true, DEFAULT_AGENTS are skipped during registration. */
 let disableDefaults = false;
 /** Check whether default agents are disabled. */
-export function isDefaultsDisabled() { return disableDefaults; }
+function isDefaultsDisabled() { return disableDefaults; }
 /** Set whether default agents are disabled. */
-export function setDefaultsDisabled(b) { disableDefaults = b; }
+function setDefaultsDisabled(b) { disableDefaults = b; }
 /**
  * Register agents into the unified registry.
  * Starts with DEFAULT_AGENTS, then overlays user agents (overrides defaults with same name).
  * Disabled agents (enabled === false) are kept in the registry but excluded from spawning.
  */
-export function registerAgents(userAgents) {
+function registerAgents(userAgents) {
     agents.clear();
     // Start with defaults (unless disabled via settings)
     if (!disableDefaults) {
-        for (const [name, config] of DEFAULT_AGENTS) {
+        for (const [name, config] of default_agents_js_1.DEFAULT_AGENTS) {
             agents.set(name, config);
         }
     }
@@ -50,9 +68,9 @@ export function registerAgents(userAgents) {
  * them as the highest-priority layer. Auto-registers agents that don't
  * exist in the registry yet.
  */
-export function applyNicoOverrides() {
-    const { overrides, defaultModel } = readNicoAgentOverrides(process.cwd());
-    applyNicoOverridesToMap(agents, overrides, defaultModel);
+function applyNicoOverrides() {
+    const { overrides, defaultModel } = (0, nico_overrides_js_1.readNicoAgentOverrides)(process.cwd());
+    (0, nico_overrides_js_1.applyNicoOverridesToMap)(agents, overrides, defaultModel);
 }
 /** Case-insensitive key resolution. */
 function resolveKey(name) {
@@ -66,38 +84,38 @@ function resolveKey(name) {
     return undefined;
 }
 /** Resolve a type name case-insensitively. Returns the canonical key or undefined. */
-export function resolveType(name) {
+function resolveType(name) {
     return resolveKey(name);
 }
 /** Get the agent config for a type (case-insensitive). */
-export function getAgentConfig(name) {
+function getAgentConfig(name) {
     const key = resolveKey(name);
     return key ? agents.get(key) : undefined;
 }
 /** Get all enabled type names (for spawning and tool descriptions). */
-export function getAvailableTypes() {
+function getAvailableTypes() {
     return [...agents.entries()]
         .filter(([_, config]) => config.enabled !== false)
         .map(([name]) => name);
 }
 /** Get all type names including disabled (for UI listing). */
-export function getAllTypes() {
+function getAllTypes() {
     return [...agents.keys()];
 }
 /** Get names of default agents currently in the registry. */
-export function getDefaultAgentNames() {
+function getDefaultAgentNames() {
     return [...agents.entries()]
         .filter(([_, config]) => config.isDefault === true)
         .map(([name]) => name);
 }
 /** Get names of user-defined agents (non-defaults) currently in the registry. */
-export function getUserAgentNames() {
+function getUserAgentNames() {
     return [...agents.entries()]
         .filter(([_, config]) => config.isDefault !== true)
         .map(([name]) => name);
 }
 /** Check if a type is valid and enabled (case-insensitive). */
-export function isValidType(type) {
+function isValidType(type) {
     const key = resolveKey(type);
     if (!key)
         return false;
@@ -108,7 +126,7 @@ const MEMORY_TOOL_NAMES = ["read", "write", "edit"];
 /**
  * Get memory tool names (read/write/edit) not already in the provided set.
  */
-export function getMemoryToolNames(existingToolNames) {
+function getMemoryToolNames(existingToolNames) {
     return MEMORY_TOOL_NAMES.filter(n => !existingToolNames.has(n));
 }
 /** Tool names needed for read-only memory access. */
@@ -116,27 +134,27 @@ const READONLY_MEMORY_TOOL_NAMES = ["read"];
 /**
  * Get read-only memory tool names not already in the provided set.
  */
-export function getReadOnlyMemoryToolNames(existingToolNames) {
+function getReadOnlyMemoryToolNames(existingToolNames) {
     return READONLY_MEMORY_TOOL_NAMES.filter(n => !existingToolNames.has(n));
 }
 /** Get built-in tool names for a type (case-insensitive). */
-export function getToolNamesForType(type) {
+function getToolNamesForType(type) {
     const key = resolveKey(type);
     const raw = key ? agents.get(key) : undefined;
     const config = raw?.enabled !== false ? raw : undefined;
     // `undefined` (definition omitted the field) → all built-ins; an explicit `[]`
     // (`tools: none` or a `tools:` with only `ext:` entries) → zero built-ins.
-    return config?.builtinToolNames ?? [...BUILTIN_TOOL_NAMES];
+    return config?.builtinToolNames ?? [...exports.BUILTIN_TOOL_NAMES];
 }
 /** Get config for a type (case-insensitive, returns a SubagentTypeConfig-compatible object). Falls back to general-purpose. */
-export function getConfig(type) {
+function getConfig(type) {
     const key = resolveKey(type);
     const config = key ? agents.get(key) : undefined;
     if (config && config.enabled !== false) {
         return {
             displayName: config.displayName ?? config.name,
             description: config.description,
-            builtinToolNames: config.builtinToolNames ?? BUILTIN_TOOL_NAMES,
+            builtinToolNames: config.builtinToolNames ?? exports.BUILTIN_TOOL_NAMES,
             extensions: config.extensions,
             excludeExtensions: config.excludeExtensions,
             skills: config.skills,
@@ -149,7 +167,7 @@ export function getConfig(type) {
         return {
             displayName: gp.displayName ?? gp.name,
             description: gp.description,
-            builtinToolNames: gp.builtinToolNames ?? BUILTIN_TOOL_NAMES,
+            builtinToolNames: gp.builtinToolNames ?? exports.BUILTIN_TOOL_NAMES,
             extensions: gp.extensions,
             excludeExtensions: gp.excludeExtensions,
             skills: gp.skills,
@@ -160,7 +178,7 @@ export function getConfig(type) {
     return {
         displayName: "Agent",
         description: "General-purpose agent for complex, multi-step tasks",
-        builtinToolNames: BUILTIN_TOOL_NAMES,
+        builtinToolNames: exports.BUILTIN_TOOL_NAMES,
         extensions: true,
         skills: true,
         promptMode: "append",

package/dist/context.js

@@ -1,8 +1,12 @@
+"use strict";
 /**
  * context.ts — Extract parent conversation context for subagent inheritance.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractText = extractText;
+exports.buildParentContext = buildParentContext;
 /** Extract text from a message content block array. */
-export function extractText(content) {
+function extractText(content) {
     return content
         .filter((c) => c.type === "text")
         .map((c) => c.text ?? "")
@@ -13,7 +17,7 @@ export function extractText(content) {
  * Used when inherit_context is true to give the subagent visibility
  * into what has been discussed/done so far.
  */
-export function buildParentContext(ctx) {
+function buildParentContext(ctx) {
     const entries = ctx.sessionManager.getBranch();
     if (!entries || entries.length === 0)
         return "";

package/dist/cross-extension-rpc.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Cross-extension RPC handlers for the subagents extension.
  *
@@ -8,9 +9,12 @@
  *   success → { success: true, data?: T }
  *   error   → { success: false, error: string }
  */
-import { resolveModel } from "./model-resolver.js";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROTOCOL_VERSION = void 0;
+exports.registerRpcHandlers = registerRpcHandlers;
+const model_resolver_js_1 = require("./model-resolver.js");
 /** RPC protocol version — bumped when the envelope or method contracts change. */
-export const PROTOCOL_VERSION = 2;
+exports.PROTOCOL_VERSION = 2;
 /**
  * Wire a single RPC handler: listen on `channel`, run `fn(params)`,
  * emit the reply envelope on `channel:reply:${requestId}`.
@@ -36,10 +40,10 @@ function handleRpc(events, channel, fn) {
  * Register ping, spawn, and stop RPC handlers on the event bus.
  * Returns unsub functions for cleanup.
  */
-export function registerRpcHandlers(deps) {
+function registerRpcHandlers(deps) {
     const { events, pi, getCtx, manager } = deps;
     const unsubPing = handleRpc(events, "subagents:rpc:ping", () => {
-        return { version: PROTOCOL_VERSION };
+        return { version: exports.PROTOCOL_VERSION };
     });
     const unsubSpawn = handleRpc(events, "subagents:rpc:spawn", ({ type, prompt, options }) => {
         const ctx = getCtx();
@@ -57,7 +61,7 @@ export function registerRpcHandlers(deps) {
             if (!registry) {
                 throw new Error(`Model override "${normalizedOptions.model}" provided but ctx.modelRegistry is unavailable`);
             }
-            const resolved = resolveModel(normalizedOptions.model, registry);
+            const resolved = (0, model_resolver_js_1.resolveModel)(normalizedOptions.model, registry);
             if (typeof resolved === "string") {
                 // resolveModel returns a human-readable error string when the
                 // input doesn't match any available model. Surface it instead of

package/dist/custom-agents.js

@@ -1,10 +1,13 @@
+"use strict";
 /**
  * custom-agents.ts — Load user-defined agents from project (.pi/agents/, plus the shared .agents/agents/ workspace) and global ($PI_CODING_AGENT_DIR/agents/, default ~/.pi/agent/agents/) locations.
  */
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { basename, join } from "node:path";
-import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import { BUILTIN_TOOL_NAMES } from "./agent-types.js";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCustomAgents = loadCustomAgents;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
+const agent_types_js_1 = require("./agent-types.js");
 /**
  * Scan for custom agent .md files from multiple locations.
  * Discovery hierarchy (higher priority wins):
@@ -17,10 +20,10 @@ import { BUILTIN_TOOL_NAMES } from "./agent-types.js";
  * authority; .agents/agents is an additional read location.
  * Any name is allowed — names matching defaults (e.g. "Explore") override them.
  */
-export function loadCustomAgents(cwd) {
-    const globalDir = join(getAgentDir(), "agents");
-    const workspaceProjectDir = join(cwd, ".agents", "agents");
-    const projectDir = join(cwd, ".pi", "agents");
+function loadCustomAgents(cwd) {
+    const globalDir = (0, node_path_1.join)((0, pi_coding_agent_1.getAgentDir)(), "agents");
+    const workspaceProjectDir = (0, node_path_1.join)(cwd, ".agents", "agents");
+    const projectDir = (0, node_path_1.join)(cwd, ".pi", "agents");
     const agents = new Map();
     loadFromDir(globalDir, agents, "global"); // lowest priority
     loadFromDir(workspaceProjectDir, agents, "project"); // shared workspace
@@ -29,25 +32,25 @@ export function loadCustomAgents(cwd) {
 }
 /** Load agent configs from a directory into the map. */
 function loadFromDir(dir, agents, source) {
-    if (!existsSync(dir))
+    if (!(0, node_fs_1.existsSync)(dir))
         return;
     let files;
     try {
-        files = readdirSync(dir).filter(f => f.endsWith(".md"));
+        files = (0, node_fs_1.readdirSync)(dir).filter(f => f.endsWith(".md"));
     }
     catch {
         return;
     }
     for (const file of files) {
-        const name = basename(file, ".md");
+        const name = (0, node_path_1.basename)(file, ".md");
         let content;
         try {
-            content = readFileSync(join(dir, file), "utf-8");
+            content = (0, node_fs_1.readFileSync)((0, node_path_1.join)(dir, file), "utf-8");
         }
         catch {
             continue;
         }
-        const { frontmatter: fm, body } = parseFrontmatter(content);
+        const { frontmatter: fm, body } = (0, pi_coding_agent_1.parseFrontmatter)(content);
         const { builtinToolNames, extSelectors } = parseToolsField(fm.tools);
         agents.set(name, {
             name,
@@ -116,13 +119,13 @@ function csvList(val, defaults) {
  * `tools:` present with only `ext:` entries → zero built-ins (use `*`).
  */
 function parseToolsField(val) {
-    const entries = csvList(val, BUILTIN_TOOL_NAMES);
+    const entries = csvList(val, agent_types_js_1.BUILTIN_TOOL_NAMES);
     const isWildcard = (e) => e === "*" || e.toLowerCase() === "all";
     const hasWildcard = entries.some(isWildcard);
     const plain = entries.filter(e => !isWildcard(e) && !e.startsWith("ext:"));
     const extEntries = entries.filter(e => e.startsWith("ext:"));
     return {
-        builtinToolNames: hasWildcard ? [...new Set([...BUILTIN_TOOL_NAMES, ...plain])] : plain,
+        builtinToolNames: hasWildcard ? [...new Set([...agent_types_js_1.BUILTIN_TOOL_NAMES, ...plain])] : plain,
         extSelectors: extEntries.length > 0 ? extEntries : undefined,
     };
 }

package/dist/default-agents.js

@@ -1,10 +1,13 @@
+"use strict";
 /**
  * default-agents.ts — Embedded default agent configurations.
  *
  * These are always available but can be overridden by user .md files with the same name.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_AGENTS = void 0;
 const READ_ONLY_TOOLS = ["read", "bash", "grep", "find", "ls"];
-export const DEFAULT_AGENTS = new Map([
+exports.DEFAULT_AGENTS = new Map([
     [
         "general-purpose",
         {

package/dist/enabled-models.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Reads `enabledModels` from pi's settings (global `<agentDir>/settings.json`
  * + project-local `<cwd>/.pi/settings.json`, project wins) and resolves
@@ -25,22 +26,26 @@
  *   enabledModels = ["anthropic/claude-sonnet-4-6", "anthropic/claude-opus-4-6"]
  *   → resolves to { "anthropic/claude-sonnet-4-6", "anthropic/claude-opus-4-6" }
  */
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEnabledModels = readEnabledModels;
+exports.resolveEnabledModels = resolveEnabledModels;
+exports.isModelInScope = isModelInScope;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
 /** Paths to pi's settings.json files: [project, global] (project takes precedence). */
 function settingsPaths(cwd) {
     return [
-        join(cwd, ".pi", "settings.json"),
-        join(getAgentDir(), "settings.json"),
+        (0, node_path_1.join)(cwd, ".pi", "settings.json"),
+        (0, node_path_1.join)((0, pi_coding_agent_1.getAgentDir)(), "settings.json"),
     ];
 }
 /** Read `enabledModels` from a single settings.json file. Undefined when missing or absent. */
 function readField(path) {
-    if (!existsSync(path))
+    if (!(0, node_fs_1.existsSync)(path))
         return undefined;
     try {
-        const raw = JSON.parse(readFileSync(path, "utf-8"));
+        const raw = JSON.parse((0, node_fs_1.readFileSync)(path, "utf-8"));
         if (Array.isArray(raw?.enabledModels))
             return raw.enabledModels;
     }
@@ -55,7 +60,7 @@ function readField(path) {
  * (and matches our own loadSettings precedence in src/settings.ts).
  * Returns undefined when neither file has the field.
  */
-export function readEnabledModels(cwd) {
+function readEnabledModels(cwd) {
     const [project, global] = settingsPaths(cwd);
     return readField(project) ?? readField(global);
 }
@@ -80,14 +85,14 @@ let cachedPatternsKey = "";
 /** mtime+size hash of one file, or "missing" if absent. */
 function hashOf(path) {
     try {
-        const s = statSync(path);
+        const s = (0, node_fs_1.statSync)(path);
         return `${s.mtimeMs}-${s.size}`;
     }
     catch {
         return "missing";
     }
 }
-export function resolveEnabledModels(patterns, registry, cwd = process.cwd()) {
+function resolveEnabledModels(patterns, registry, cwd = process.cwd()) {
     // Fast path: check cache (stat both project and global settings.json files)
     const patternsKey = JSON.stringify(patterns);
     const [project, global] = settingsPaths(cwd);
@@ -121,7 +126,7 @@ export function resolveEnabledModels(patterns, registry, cwd = process.cwd()) {
  * (`provider/id` lowercase) so callers don't have to reproduce it —
  * both set-building (resolveExact) and lookup go through `modelKey`.
  */
-export function isModelInScope(model, allowed) {
+function isModelInScope(model, allowed) {
     return allowed.has(modelKey(model));
 }
 /** Canonical lowercase `provider/id` key for the allowed set. */

package/dist/env.js

@@ -1,7 +1,10 @@
+"use strict";
 /**
  * env.ts — Detect environment info (git, platform) for subagent system prompts.
  */
-export async function detectEnv(pi, cwd) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectEnv = detectEnv;
+async function detectEnv(pi, cwd) {
     let isGitRepo = false;
     let branch = "";
     try {

package/dist/group-join.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * group-join.ts — Manages grouped background agent completion notifications.
  *
@@ -5,11 +6,13 @@
  * agents in a group are held until all complete (or a timeout fires),
  * then a single consolidated notification is sent.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupJoinManager = void 0;
 /** Default timeout: 30s after first completion in a group. */
 const DEFAULT_TIMEOUT = 30_000;
 /** Straggler re-batch timeout: 15s. */
 const STRAGGLER_TIMEOUT = 15_000;
-export class GroupJoinManager {
+class GroupJoinManager {
     deliverCb;
     groupTimeout;
     groups = new Map();
@@ -114,3 +117,4 @@ export class GroupJoinManager {
         this.agentToGroup.clear();
     }
 }
+exports.GroupJoinManager = GroupJoinManager;