@tianhai/pi-workflow-kit 0.4.1

package/extensions/subagent/agents.ts

@@ -0,0 +1,144 @@
+/**
+ * Agent discovery and configuration
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseFrontmatter } from "@mariozechner/pi-coding-agent";
+import { log } from "../lib/logging.js";
+
+export type AgentScope = "user" | "project" | "both";
+
+export interface AgentConfig {
+  name: string;
+  description: string;
+  tools?: string[];
+  extensions?: string[];
+  model?: string;
+  systemPrompt: string;
+  source: "user" | "project" | "bundled";
+  filePath: string;
+}
+
+export interface AgentDiscoveryResult {
+  agents: AgentConfig[];
+  projectAgentsDir: string | null;
+}
+
+export function loadAgentsFromDir(dir: string, source: "user" | "project" | "bundled"): AgentConfig[] {
+  const agents: AgentConfig[] = [];
+
+  if (!fs.existsSync(dir)) {
+    return agents;
+  }
+
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    log.warn(`Failed to read agents directory: ${dir} — ${err instanceof Error ? err.message : err}`);
+    return agents;
+  }
+
+  for (const entry of entries) {
+    if (!entry.name.endsWith(".md")) continue;
+    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+
+    const filePath = path.join(dir, entry.name);
+    let content: string;
+    try {
+      content = fs.readFileSync(filePath, "utf-8");
+    } catch (err) {
+      log.warn(`Failed to read agent file: ${filePath} — ${err instanceof Error ? err.message : err}`);
+      continue;
+    }
+
+    const { frontmatter, body } = parseFrontmatter<Record<string, string>>(content);
+
+    if (!frontmatter.name || !frontmatter.description) {
+      continue;
+    }
+
+    const tools = frontmatter.tools
+      ?.split(",")
+      .map((t: string) => t.trim())
+      .filter(Boolean);
+    const extensions = frontmatter.extensions
+      ?.split(",")
+      .map((t: string) => t.trim())
+      .filter(Boolean);
+
+    agents.push({
+      name: frontmatter.name,
+      description: frontmatter.description,
+      tools: tools && tools.length > 0 ? tools : undefined,
+      extensions: extensions && extensions.length > 0 ? extensions : undefined,
+      model: frontmatter.model,
+      systemPrompt: body,
+      source,
+      filePath,
+    });
+  }
+
+  return agents;
+}
+
+function isDirectory(p: string): boolean {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch (err) {
+    log.debug(`stat failed for ${p}: ${err instanceof Error ? err.message : err}`);
+    return false;
+  }
+}
+
+function findNearestProjectAgentsDir(cwd: string): string | null {
+  let currentDir = cwd;
+  while (true) {
+    const candidate = path.join(currentDir, ".pi", "agents");
+    if (isDirectory(candidate)) return candidate;
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) return null;
+    currentDir = parentDir;
+  }
+}
+
+export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
+  const userDir = path.join(os.homedir(), ".pi", "agent", "agents");
+  const projectAgentsDir = findNearestProjectAgentsDir(cwd);
+  const thisFile = fileURLToPath(import.meta.url);
+  const packageRoot = path.resolve(path.dirname(thisFile), "..", "..");
+  const bundledAgentsDir = path.join(packageRoot, "agents");
+
+  const userAgents = scope === "project" ? [] : loadAgentsFromDir(userDir, "user");
+  const projectAgents = scope === "user" || !projectAgentsDir ? [] : loadAgentsFromDir(projectAgentsDir, "project");
+  const bundledAgents = scope === "user" ? [] : loadAgentsFromDir(bundledAgentsDir, "bundled");
+
+  const agentMap = new Map<string, AgentConfig>();
+
+  if (scope === "both") {
+    for (const agent of bundledAgents) agentMap.set(agent.name, agent);
+    for (const agent of userAgents) agentMap.set(agent.name, agent);
+    for (const agent of projectAgents) agentMap.set(agent.name, agent);
+  } else if (scope === "user") {
+    for (const agent of userAgents) agentMap.set(agent.name, agent);
+  } else {
+    for (const agent of bundledAgents) agentMap.set(agent.name, agent);
+    for (const agent of projectAgents) agentMap.set(agent.name, agent);
+  }
+
+  return { agents: Array.from(agentMap.values()), projectAgentsDir };
+}
+
+export function formatAgentList(agents: AgentConfig[], maxItems: number): { text: string; remaining: number } {
+  if (agents.length === 0) return { text: "none", remaining: 0 };
+  const listed = agents.slice(0, maxItems);
+  const remaining = agents.length - listed.length;
+  return {
+    text: listed.map((a) => `${a.name} (${a.source}): ${a.description}`).join("; "),
+    remaining,
+  };
+}

package/extensions/subagent/concurrency.ts

@@ -0,0 +1,52 @@
+export const DEFAULT_SUBAGENT_CONCURRENCY = 6;
+
+export function getSubagentConcurrency(): number {
+  const envVal = process.env.PI_SUBAGENT_CONCURRENCY;
+  if (envVal) {
+    const parsed = Number.parseInt(envVal, 10);
+    if (Number.isFinite(parsed)) return Math.max(1, parsed);
+  }
+  return DEFAULT_SUBAGENT_CONCURRENCY;
+}
+
+export class Semaphore {
+  private _active = 0;
+  private _queue: Array<() => void> = [];
+
+  constructor(private _limit: number) {}
+
+  get limit(): number {
+    return this._limit;
+  }
+
+  get active(): number {
+    return this._active;
+  }
+  get waiting(): number {
+    return this._queue.length;
+  }
+
+  async acquire(): Promise<() => void> {
+    if (this._active < this._limit) {
+      this._active++;
+      return this._createRelease();
+    }
+    return new Promise<() => void>((resolve) => {
+      this._queue.push(() => {
+        this._active++;
+        resolve(this._createRelease());
+      });
+    });
+  }
+
+  private _createRelease(): () => void {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this._active--;
+      const next = this._queue.shift();
+      if (next) next();
+    };
+  }
+}

package/extensions/subagent/env.ts

@@ -0,0 +1,47 @@
+const ALLOWED_PREFIXES = ["PI_", "NODE_", "NPM_", "NVM_", "LC_", "XDG_"];
+
+const ALLOWED_EXPLICIT = new Set([
+  "PATH",
+  "HOME",
+  "SHELL",
+  "TERM",
+  "USER",
+  "LOGNAME",
+  "TMPDIR",
+  "EDITOR",
+  "VISUAL",
+  "SSH_AUTH_SOCK",
+  "COLORTERM",
+  "FORCE_COLOR",
+  "NO_COLOR",
+  "LANG",
+  "LANGUAGE",
+]);
+
+export function buildSubagentEnv(extra?: Record<string, string>): Record<string, string | undefined> {
+  const filtered: Record<string, string | undefined> = {};
+
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value === undefined) continue;
+    if (ALLOWED_EXPLICIT.has(key) || ALLOWED_PREFIXES.some((p) => key.startsWith(p))) {
+      filtered[key] = value;
+    }
+  }
+
+  const passthrough = process.env.PI_SUBAGENT_ENV_PASSTHROUGH;
+  if (passthrough) {
+    for (const name of passthrough
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean)) {
+      const val = process.env[name];
+      if (val !== undefined) filtered[name] = val;
+    }
+  }
+
+  if (extra) {
+    Object.assign(filtered, extra);
+  }
+
+  return filtered;
+}