@mystilleef/pi-subagent 0.11.0 → 0.12.1

package/src/shared/resource-resolution.ts

@@ -0,0 +1,289 @@
+/**
+ * Generic resource resolution for skills and extensions.
+ * Handles caching, discovery via DefaultResourceLoader, and name-to-path mapping.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  DefaultResourceLoader,
+  getAgentDir,
+} from "@earendil-works/pi-coding-agent";
+
+const RESOURCE_DISCOVERY_CACHE_TTL_MS = 300_000;
+
+export const EXTENSION_DISCOVERY_CACHE_TTL_MS = RESOURCE_DISCOVERY_CACHE_TTL_MS;
+
+type ResourceCacheEntry<T> = {
+  data: T;
+  ts: number;
+};
+
+class ResourceCache<T> {
+  private store = new Map<string, ResourceCacheEntry<T>>();
+
+  get(key: string): T | undefined {
+    const entry = this.store.get(key);
+    if (entry && Date.now() - entry.ts <= RESOURCE_DISCOVERY_CACHE_TTL_MS) {
+      return entry.data;
+    }
+    return undefined;
+  }
+
+  set(key: string, data: T): void {
+    this.store.set(key, { data, ts: Date.now() });
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+}
+
+const skillArgsCache = new ResourceCache<Map<string, string>>();
+const extensionPathsCache = new ResourceCache<Map<string, string>>();
+
+export function resetResolvedAgentSkillArgsCache(): void {
+  skillArgsCache.clear();
+}
+
+export function resetResolvedAgentExtensionPathsCache(): void {
+  extensionPathsCache.clear();
+}
+
+async function canonicalPath(filePath: string): Promise<string> {
+  try {
+    return await fs.promises.realpath(filePath);
+  } catch {
+    /* symlinks or missing paths fall back to absolute path resolution */
+    return path.resolve(filePath);
+  }
+}
+
+async function buildResourceCacheKey(
+  cwd: string,
+  agentDir: string,
+  names: string[],
+): Promise<string> {
+  const sortedNames = [...names].sort();
+  return JSON.stringify({
+    cwd: await canonicalPath(cwd),
+    agentDir: await canonicalPath(agentDir),
+    names: sortedNames,
+  });
+}
+
+type ResourceResolverResult<T> = { data: T } | { error: string };
+
+interface ResourceResolverConfig<TResult> {
+  cache: ResourceCache<Map<string, string>>;
+  loaderOptions: Record<string, boolean>;
+  getResources: (loader: DefaultResourceLoader) => {
+    items: unknown[];
+    errors: Array<{ path: string; error: string }>;
+  };
+  buildNameToResource: (items: unknown[]) => Map<string, string>;
+  buildResult: (
+    requested: string[],
+    nameToResource: Map<string, string>,
+  ) => TResult;
+  resourceType: string;
+}
+
+async function resolveResources<TResult>(
+  cwd: string,
+  names: string[],
+  config: ResourceResolverConfig<TResult>,
+): Promise<ResourceResolverResult<TResult>> {
+  const requested = Array.from(new Set(names));
+  if (requested.length === 0) {
+    return { data: config.buildResult(requested, new Map()) };
+  }
+  const agentDir = getAgentDir();
+  const cacheKey = await buildResourceCacheKey(cwd, agentDir, requested);
+  const cached = config.cache.get(cacheKey);
+  if (cached) {
+    return { data: config.buildResult(requested, cached) };
+  }
+  const loader = new DefaultResourceLoader({
+    cwd,
+    agentDir,
+    ...config.loaderOptions,
+  });
+  try {
+    await loader.reload();
+  } catch (error) {
+    return {
+      error: `Failed to discover ${config.resourceType}s: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+  const { items, errors } = config.getResources(loader);
+  if (errors.length > 0) {
+    const details = errors.map((e) => `  ${e.path}: ${e.error}`).join("\n");
+    return {
+      error: `Failed to discover ${config.resourceType}s:\n${details}`,
+    };
+  }
+  const nameToResource = config.buildNameToResource(items);
+  const missing = requested.filter((name) => !nameToResource.has(name));
+  if (missing.length > 0) {
+    const available =
+      Array.from(nameToResource.keys()).sort().join(", ") || "none";
+    return {
+      error: `Unknown ${config.resourceType}${missing.length === 1 ? "" : "s"}: ${missing
+        .map((name) => `"${name}"`)
+        .join(", ")}. Available ${config.resourceType}s: ${available}.`,
+    };
+  }
+  const result = config.buildResult(requested, nameToResource);
+  config.cache.set(cacheKey, nameToResource);
+  return { data: result };
+}
+
+function buildSkillArgs(
+  requested: string[],
+  skillPaths: Map<string, string>,
+): string[] {
+  return requested.flatMap((name) => ["--skill", skillPaths.get(name) ?? name]);
+}
+
+export async function resolveAgentSkillArgs(
+  cwd: string,
+  skillNames: string[],
+): Promise<{ args: string[] } | { error: string }> {
+  const result = await resolveResources(cwd, skillNames, {
+    cache: skillArgsCache,
+    loaderOptions: {
+      noContextFiles: true,
+      noPromptTemplates: true,
+      noThemes: true,
+    },
+    getResources: (loader) => {
+      const { skills } = loader.getSkills();
+      return {
+        items: skills,
+        errors: [],
+      };
+    },
+    buildNameToResource: (items) => {
+      const skillMap = new Map<string, string>();
+      for (const item of items) {
+        const skill = item as { name: string; filePath: string };
+        skillMap.set(skill.name, skill.filePath ?? skill.name);
+      }
+      return skillMap;
+    },
+    buildResult: (requested, nameToResource) => {
+      return buildSkillArgs(requested, nameToResource);
+    },
+    resourceType: "skill",
+  });
+  return "error" in result ? result : { args: result.data };
+}
+
+function getTerminalPackageName(source: string): string {
+  const spec = source.startsWith("npm:") ? source.slice(4) : source;
+  let name: string;
+  if (spec.startsWith("@")) {
+    const slashIdx = spec.indexOf("/");
+    if (slashIdx >= 0) {
+      name = spec.slice(slashIdx + 1);
+    } else {
+      name = spec;
+    }
+  } else {
+    name = spec;
+  }
+  const versionIdx = name.indexOf("@");
+  if (versionIdx >= 0) {
+    return name.slice(0, versionIdx);
+  }
+  return name;
+}
+
+function isLocalPathSpec(source: string): boolean {
+  return (
+    source.startsWith(".") ||
+    source.startsWith("/") ||
+    source.startsWith("~") ||
+    source.startsWith("file:")
+  );
+}
+
+function buildExtensionShortName(ext: {
+  resolvedPath: string;
+  sourceInfo: { source: string; origin: string };
+}): string {
+  if (
+    ext.sourceInfo.origin === "package" &&
+    !isLocalPathSpec(ext.sourceInfo.source)
+  ) {
+    return getTerminalPackageName(ext.sourceInfo.source);
+  }
+  const fileName = path.basename(ext.resolvedPath);
+  if (/^index\.(?:ts|js)$/.test(fileName)) {
+    const dirName = path.dirname(ext.resolvedPath);
+    const base = path.basename(dirName);
+    if (base === "src" || base === "dist") {
+      return path.basename(path.dirname(dirName));
+    }
+    return base;
+  }
+  const dotIdx = fileName.lastIndexOf(".");
+  if (dotIdx > 0) {
+    return fileName.slice(0, dotIdx);
+  }
+  return fileName;
+}
+
+export async function resolveAgentExtensionPaths(
+  cwd: string,
+  extensionNames: string[],
+): Promise<{ resolvedPaths: string[] } | { error: string }> {
+  const result = await resolveResources(cwd, extensionNames, {
+    cache: extensionPathsCache,
+    loaderOptions: {
+      noContextFiles: true,
+      noPromptTemplates: true,
+      noThemes: true,
+      noSkills: true,
+    },
+    getResources: (loader) => {
+      const { extensions, errors } = loader.getExtensions();
+      const shortNameToExtension = new Map<
+        string,
+        (typeof extensions)[number]
+      >();
+      for (const ext of extensions) {
+        const shortName = buildExtensionShortName(ext);
+        if (!shortNameToExtension.has(shortName)) {
+          shortNameToExtension.set(shortName, ext);
+        }
+      }
+      return {
+        items: Array.from(shortNameToExtension.values()),
+        errors,
+      };
+    },
+    buildNameToResource: (items) => {
+      const shortNameToPath = new Map<string, string>();
+      for (const item of items) {
+        const ext = item as {
+          resolvedPath: string;
+          sourceInfo: { source: string; origin: string };
+        };
+        const shortName = buildExtensionShortName(ext);
+        if (!shortNameToPath.has(shortName)) {
+          shortNameToPath.set(shortName, ext.resolvedPath ?? shortName);
+        }
+      }
+      return shortNameToPath;
+    },
+    buildResult: (requested, nameToResource) => {
+      return requested
+        .map((name) => nameToResource.get(name))
+        .filter((p): p is string => typeof p === "string");
+    },
+    resourceType: "extension",
+  });
+  return "error" in result ? result : { resolvedPaths: result.data };
+}

package/src/shared/utils.ts

@@ -1,261 +1,35 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import type { Message } from "@earendil-works/pi-ai";
-import {
-  DefaultResourceLoader,
-  getAgentDir,
-} from "@earendil-works/pi-coding-agent";
-import type { SingleResult } from "./types.js";
-
-export const DEFAULT_MAX_OUTPUT_BYTES = 50_000;
-export const DEFAULT_MAX_OUTPUT_LINES = 500;
-export const DEFAULT_AGENT_END_GRACE_MS = 250;
-export const DEFAULT_MAX_STDERR_BYTES = 10_000;
-export const DEFAULT_MAX_SUBAGENT_DEPTH = 3;
-const MAX_SUBAGENT_DEPTH_CEILING = 10;
-
-export interface SubagentOutputLimits {
-  maxBytes: number;
-  maxLines: number;
-}
-
-export interface SubagentRuntimeLimits {
-  agentEndGraceMs: number;
-  maxStderrBytes: number;
-  maxDepth: number;
-}
-
-type EnvLimitConfig = Partial<Record<string, string | number | undefined>>;
-
-function parsePositiveInteger(
-  value: string | number | undefined,
-): number | undefined {
-  const parsed = typeof value === "number" ? value : Number(value);
-  if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed < 1)
-    return undefined;
-  return parsed;
-}
-
-export function getSubagentOutputLimits(
-  config: EnvLimitConfig = process.env,
-): SubagentOutputLimits {
-  return {
-    maxBytes:
-      parsePositiveInteger(config["PI_SUBAGENT_MAX_OUTPUT_BYTES"]) ??
-      DEFAULT_MAX_OUTPUT_BYTES,
-    maxLines:
-      parsePositiveInteger(config["PI_SUBAGENT_MAX_OUTPUT_LINES"]) ??
-      DEFAULT_MAX_OUTPUT_LINES,
-  };
-}
-
-export function getSubagentRuntimeLimits(
-  config: EnvLimitConfig = process.env,
-): SubagentRuntimeLimits {
-  const maxDepth =
-    parsePositiveInteger(config["PI_SUBAGENT_MAX_DEPTH"]) ??
-    DEFAULT_MAX_SUBAGENT_DEPTH;
-  return {
-    agentEndGraceMs:
-      parsePositiveInteger(config["PI_SUBAGENT_AGENT_END_GRACE_MS"]) ??
-      DEFAULT_AGENT_END_GRACE_MS,
-    maxStderrBytes:
-      parsePositiveInteger(config["PI_SUBAGENT_MAX_STDERR_BYTES"]) ??
-      DEFAULT_MAX_STDERR_BYTES,
-    maxDepth: Math.min(maxDepth, MAX_SUBAGENT_DEPTH_CEILING),
-  };
-}
-
-export function truncateOutput(
-  text: string,
-  limits: SubagentOutputLimits = getSubagentOutputLimits(),
-): string {
-  const lines = text.split("\n");
-  const maxBytes = Math.max(1, Math.floor(limits.maxBytes));
-  const maxLines = Math.max(1, Math.floor(limits.maxLines));
-  if (lines.length <= maxLines && Buffer.byteLength(text, "utf-8") <= maxBytes)
-    return text;
-  let result = lines.slice(0, maxLines).join("\n");
-  if (Buffer.byteLength(result, "utf-8") > maxBytes) {
-    const buf = Buffer.from(result).subarray(0, maxBytes);
-    result = buf.toString("utf-8").replace(/\uFFFD$/, "");
-  }
-  const kept = result.split("\n").length;
-  return `[TRUNCATED: first ${kept} of ${lines.length} lines]\n${result}`;
-}
-
-export async function writePromptToTempFile(
-  agentName: string,
-  prompt: string,
-): Promise<{ dir: string; filePath: string }> {
-  const tmpDir = await fs.promises.mkdtemp(
-    path.join(os.tmpdir(), "pi-subagent-"),
-  );
-  const safeName = agentName.replace(/[^\w.-]+/g, "_");
-  const filePath = path.join(tmpDir, `prompt-${safeName}.md`);
-  // mkdtemp guarantees a unique directory per call; no concurrent writer can hold this path.
-  await fs.promises.writeFile(filePath, prompt, {
-    encoding: "utf-8",
-    mode: 0o600,
-  });
-  return { dir: tmpDir, filePath };
-}
-
-export function getPiInvocation(args: string[]): {
-  command: string;
-  args: string[];
-} {
-  const currentScript = process.argv[1];
-  if (currentScript && fs.existsSync(currentScript)) {
-    return { command: process.execPath, args: [currentScript, ...args] };
-  }
-  const execName = path.basename(process.execPath).toLowerCase();
-  const isGenericRuntime = /^(node|bun)(\.exe)?$/.test(execName);
-  if (!isGenericRuntime) {
-    return { command: process.execPath, args };
-  }
-  return { command: "pi", args };
-}
-
-const SKILL_DISCOVERY_CACHE_TTL_MS = 300_000;
-
-type ResolvedSkillArgsCacheEntry = {
-  skillPaths: Map<string, string>;
-  ts: number;
-};
-
-const resolvedSkillArgsCache = new Map<string, ResolvedSkillArgsCacheEntry>();
-
-async function canonicalPath(filePath: string): Promise<string> {
-  try {
-    return await fs.promises.realpath(filePath);
-  } catch {
-    /* symlinks or missing paths fall back to absolute path resolution */
-    return path.resolve(filePath);
-  }
-}
-
-function buildSkillArgs(
-  requested: string[],
-  skillPaths: Map<string, string>,
-): string[] {
-  return requested.flatMap((name) => ["--skill", skillPaths.get(name) ?? name]);
-}
-
-export function resetResolvedAgentSkillArgsCache(): void {
-  resolvedSkillArgsCache.clear();
-}
-
-export async function resolveAgentSkillArgs(
-  cwd: string,
-  skillNames: string[],
-): Promise<{ args: string[] } | { error: string }> {
-  const requested = Array.from(new Set(skillNames));
-  if (requested.length === 0) return { args: [] };
-  const cacheIdentitySkills = [...requested].sort();
-  const agentDir = getAgentDir();
-  const cacheKey = JSON.stringify({
-    cwd: await canonicalPath(cwd),
-    agentDir: await canonicalPath(agentDir),
-    skills: cacheIdentitySkills,
-  });
-  const cached = resolvedSkillArgsCache.get(cacheKey);
-  if (cached && Date.now() - cached.ts <= SKILL_DISCOVERY_CACHE_TTL_MS) {
-    return { args: buildSkillArgs(requested, cached.skillPaths) };
-  }
-  const loader = new DefaultResourceLoader({
-    cwd,
-    agentDir,
-    noContextFiles: true,
-    noPromptTemplates: true,
-    noThemes: true,
-  });
-  try {
-    await loader.reload();
-  } catch (error) {
-    return {
-      error: `Failed to discover skills: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-  const { skills } = loader.getSkills();
-  const skillMap = new Map(skills.map((skill) => [skill.name, skill]));
-  const missing = requested.filter((name) => !skillMap.has(name));
-  if (missing.length > 0) {
-    const available =
-      skills
-        .map((skill) => skill.name)
-        .sort()
-        .join(", ") || "none";
-    return {
-      error: `Unknown skill${missing.length === 1 ? "" : "s"}: ${missing
-        .map((name) => `"${name}"`)
-        .join(", ")}. Available skills: ${available}.`,
-    };
-  }
-  const skillPaths = new Map(
-    requested.map((name) => [name, skillMap.get(name)?.filePath ?? name]),
-  );
-  const args = buildSkillArgs(requested, skillPaths);
-  resolvedSkillArgsCache.set(cacheKey, { skillPaths, ts: Date.now() });
-  return { args };
-}
-
-export function getSubagentDepth(): number {
-  const d = Number(process.env.PI_SUBAGENT_DEPTH ?? "0");
-  if (!Number.isFinite(d) || d < 0) return 0;
-  return Math.floor(d);
-}
-
-export function subagentDepthEnv(): Record<string, string> {
-  return { PI_SUBAGENT_DEPTH: String(getSubagentDepth() + 1) };
-}
-
-export function findLastAssistantTextMessage(messages: Message[]): number {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (
-      msg?.role === "assistant" &&
-      Array.isArray(msg.content) &&
-      msg.content.some(
-        (c) =>
-          c.type === "text" &&
-          typeof c.text === "string" &&
-          c.text.trim().length > 0,
-      )
-    ) {
-      return i;
-    }
-  }
-  return -1;
-}
-
-export function extractFinalOutputFromMessages(messages: Message[]): string {
-  const lastAsstIdx = findLastAssistantTextMessage(messages);
-  if (lastAsstIdx < 0) return "";
-  const content = messages[lastAsstIdx]?.content;
-  if (!Array.isArray(content)) return "";
-  const lastText = content.findLast((p) => p.type === "text");
-  return lastText?.type === "text" ? (lastText.text ?? "") : "";
-}
-
-export function detectMessageError(messages: Message[]): boolean {
-  const lastAssistantIdx = findLastAssistantTextMessage(messages);
-  const from = lastAssistantIdx >= 0 ? lastAssistantIdx + 1 : 0;
-  for (let i = messages.length - 1; i >= from; i--) {
-    const msg = messages[i];
-    if (msg?.role === "toolResult" && msg.isError) return true;
-  }
-  return false;
-}
-
-export function hasSubagentFailed(result: SingleResult): boolean {
-  if (result.outcome?.trim()) return false;
-  return (
-    result.exitCode !== 0 ||
-    result.stopReason === "error" ||
-    result.stopReason === "aborted" ||
-    Boolean(result.errorMessage?.trim()) ||
-    detectMessageError(result.messages ?? [])
-  );
-}
+/**
+ * Barrel export for shared utilities.
+ * Re-exports from focused modules.
+ */
+
+export { writePromptToTempFile } from "../child/prompt-setup.js";
+export {
+  getPiInvocation,
+  getSubagentDepth,
+  subagentDepthEnv,
+} from "./invocation.js";
+// Re-export all public symbols from focused modules
+export {
+  DEFAULT_AGENT_END_GRACE_MS,
+  DEFAULT_MAX_OUTPUT_BYTES,
+  DEFAULT_MAX_OUTPUT_LINES,
+  DEFAULT_MAX_STDERR_BYTES,
+  DEFAULT_MAX_SUBAGENT_DEPTH,
+  getSubagentOutputLimits,
+  getSubagentRuntimeLimits,
+  truncateOutput,
+} from "./limits.js";
+export {
+  detectMessageError,
+  extractFinalOutputFromMessages,
+  findLastAssistantTextMessage,
+  hasSubagentFailed,
+} from "./message-utils.js";
+export {
+  EXTENSION_DISCOVERY_CACHE_TTL_MS,
+  resetResolvedAgentExtensionPathsCache,
+  resetResolvedAgentSkillArgsCache,
+  resolveAgentExtensionPaths,
+  resolveAgentSkillArgs,
+} from "./resource-resolution.js";