@astrofoundry/pi-astro 0.14.6 → 0.16.0

package/extensions/astro-agents/discovery.ts

@@ -1,115 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getAgentDir, parseFrontmatter } from "@mariozechner/pi-coding-agent";
-
-export type AgentSource = "bundle" | "user" | "project";
-export type AgentScope = "user" | "project" | "both";
-
-export interface AgentConfig {
-    name: string;
-    description: string;
-    color?: string;
-    tools?: string[];
-    skills?: string[];
-    systemPrompt: string;
-    source: AgentSource;
-    filePath: string;
-}
-
-interface AgentFrontmatter extends Record<string, unknown> {
-    name?: string;
-    description?: string;
-    color?: string;
-    tools?: string;
-    skills?: unknown;
-}
-
-function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig[] {
-    if (!fs.existsSync(dir)) {
-        return [];
-    }
-
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    const agents: AgentConfig[] = [];
-
-    for (const entry of entries) {
-        if (!entry.name.endsWith(".md")) continue;
-        if (!entry.isFile() && !entry.isSymbolicLink()) continue;
-
-        const filePath = path.join(dir, entry.name);
-        const content = fs.readFileSync(filePath, "utf-8");
-        const { frontmatter, body } = parseFrontmatter<AgentFrontmatter>(content);
-
-        if (!frontmatter.name || !frontmatter.description) {
-            continue;
-        }
-
-        const tools = frontmatter.tools
-            ?.split(",")
-            .map((t) => t.trim())
-            .filter(Boolean);
-
-        let skills: string[] | undefined;
-        const rawSkills = frontmatter.skills;
-        if (Array.isArray(rawSkills)) {
-            skills = rawSkills.map((s) => String(s).trim()).filter(Boolean);
-        } else if (typeof rawSkills === "string") {
-            skills = rawSkills
-                .split(",")
-                .map((s) => s.trim())
-                .filter(Boolean);
-        }
-
-        agents.push({
-            name: frontmatter.name,
-            description: frontmatter.description,
-            color: frontmatter.color,
-            tools: tools && tools.length > 0 ? tools : undefined,
-            skills: skills && skills.length > 0 ? skills : undefined,
-            systemPrompt: body,
-            source,
-            filePath,
-        });
-    }
-
-    return agents;
-}
-
-function findNearestProjectAgentsDir(cwd: string): string | null {
-    let currentDir = cwd;
-    for (;;) {
-        const candidate = path.join(currentDir, ".pi", "agents");
-        if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
-            return candidate;
-        }
-        const parentDir = path.dirname(currentDir);
-        if (parentDir === currentDir) return null;
-        currentDir = parentDir;
-    }
-}
-
-export interface DiscoverOptions {
-    cwd: string;
-    bundleDir: string;
-    scope: AgentScope;
-}
-
-export function discoverAgents(options: DiscoverOptions): AgentConfig[] {
-    const { cwd, bundleDir, scope } = options;
-
-    const bundleAgents = loadAgentsFromDir(bundleDir, "bundle");
-
-    const userDir = path.join(getAgentDir(), "agents");
-    const userAgents = scope === "project" ? [] : loadAgentsFromDir(userDir, "user");
-
-    const projectDir = scope === "user" ? null : findNearestProjectAgentsDir(cwd);
-    const projectAgents = projectDir ? loadAgentsFromDir(projectDir, "project") : [];
-
-    const agentMap = new Map<string, AgentConfig>();
-
-    for (const agent of bundleAgents) 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);
-
-    return Array.from(agentMap.values());
-}

package/extensions/astro-agents/index.test.ts

@@ -1,214 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { AgentConfig } from "./discovery.ts";
-
-vi.mock("./discovery.ts", () => ({
-    discoverAgents: vi.fn(),
-}));
-
-vi.mock("./spawn.ts", () => ({
-    runAgent: vi.fn(),
-}));
-
-vi.mock("node:fs", async (importActual) => {
-    const actual = await importActual<typeof import("node:fs")>();
-    return { ...actual, existsSync: vi.fn(actual.existsSync) };
-});
-
-type ToolDef = {
-    name: string;
-    execute: (
-        id: string,
-        input: { agent: string; task: string; scope?: "user" | "project" | "both" },
-        signal: AbortSignal | undefined,
-        onUpdate: unknown,
-        ctx: {
-            cwd: string;
-            hasUI: boolean;
-            ui: {
-                notify: ReturnType<typeof vi.fn>;
-                confirm: ReturnType<typeof vi.fn>;
-                setStatus: ReturnType<typeof vi.fn>;
-            };
-        },
-    ) => Promise<{ content: Array<{ text: string }>; details: { agent: string; source: string } }>;
-};
-
-function makePi(): { tools: ToolDef[]; registerTool: (t: ToolDef) => void } {
-    const tools: ToolDef[] = [];
-    return { tools, registerTool: (t) => tools.push(t) };
-}
-
-function makeCtx(): {
-    cwd: string;
-    hasUI: boolean;
-    ui: {
-        notify: ReturnType<typeof vi.fn>;
-        confirm: ReturnType<typeof vi.fn>;
-        setStatus: ReturnType<typeof vi.fn>;
-    };
-} {
-    return {
-        cwd: "/tmp/test-cwd",
-        hasUI: true,
-        ui: {
-            notify: vi.fn(),
-            confirm: vi.fn().mockResolvedValue(true),
-            setStatus: vi.fn(),
-        },
-    };
-}
-
-const sampleAgent: AgentConfig = {
-    name: "scout",
-    description: "quick recon",
-    color: "red",
-    systemPrompt: "You are scout.",
-    source: "bundle",
-    filePath: "/pkg/extensions/astro-agents/agents/scout.md",
-};
-
-describe("astro-agents extension (astro_agent tool)", () => {
-    beforeEach(() => {
-        vi.resetModules();
-        vi.clearAllMocks();
-    });
-
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-
-    it("registers the astro_agent tool", async () => {
-        const { discoverAgents } = await import("./discovery.ts");
-        vi.mocked(discoverAgents).mockReturnValue([sampleAgent]);
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-        expect(pi.tools[0].name).toBe("astro_agent");
-    });
-
-    it("throws when agent name is not found; lists available", async () => {
-        const { discoverAgents } = await import("./discovery.ts");
-        vi.mocked(discoverAgents).mockReturnValue([sampleAgent]);
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-        const ctx = makeCtx();
-        await expect(
-            pi.tools[0].execute("t", { agent: "ghost", task: "x" }, undefined, undefined, ctx),
-        ).rejects.toThrow(/not found.+scout/);
-    });
-
-    it("happy path: spawns subagent and returns its text", async () => {
-        const { discoverAgents } = await import("./discovery.ts");
-        const { runAgent } = await import("./spawn.ts");
-        vi.mocked(discoverAgents).mockReturnValue([sampleAgent]);
-        vi.mocked(runAgent).mockResolvedValue({ text: "done", exitCode: 0, stderr: "" });
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-        const ctx = makeCtx();
-        const res = await pi.tools[0].execute("t", { agent: "scout", task: "recon" }, undefined, undefined, ctx);
-        expect(res.content[0].text).toBe("done");
-        expect(ctx.ui.notify).toHaveBeenCalled();
-    });
-
-    it("throws on non-zero exit", async () => {
-        const { discoverAgents } = await import("./discovery.ts");
-        const { runAgent } = await import("./spawn.ts");
-        vi.mocked(discoverAgents).mockReturnValue([sampleAgent]);
-        vi.mocked(runAgent).mockResolvedValue({ text: "", exitCode: 1, stderr: "boom" });
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-        await expect(
-            pi.tools[0].execute("t", { agent: "scout", task: "x" }, undefined, undefined, makeCtx()),
-        ).rejects.toThrow(/exited with code 1/);
-    });
-
-    it("returns placeholder when agent produced no output", async () => {
-        const { discoverAgents } = await import("./discovery.ts");
-        const { runAgent } = await import("./spawn.ts");
-        vi.mocked(discoverAgents).mockReturnValue([sampleAgent]);
-        vi.mocked(runAgent).mockResolvedValue({ text: "", exitCode: 0, stderr: "" });
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-        const res = await pi.tools[0].execute("t", { agent: "scout", task: "x" }, undefined, undefined, makeCtx());
-        expect(res.content[0].text).toMatch(/no output/);
-    });
-
-    it("prompts confirmation for project-scoped agent and respects 'no'", async () => {
-        const projectAgent = { ...sampleAgent, source: "project" as const };
-        const { discoverAgents } = await import("./discovery.ts");
-        vi.mocked(discoverAgents).mockReturnValue([projectAgent]);
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-        const ctx = makeCtx();
-        ctx.ui.confirm.mockResolvedValue(false);
-        await expect(
-            pi.tools[0].execute("t", { agent: "scout", task: "x", scope: "project" }, undefined, undefined, ctx),
-        ).rejects.toThrow(/cancelled/);
-    });
-
-    it("warns when declared skill isn't in the package", async () => {
-        const { discoverAgents } = await import("./discovery.ts");
-        const { runAgent } = await import("./spawn.ts");
-        const agentWithSkill: AgentConfig = { ...sampleAgent, skills: ["ghost-skill"] };
-        vi.mocked(discoverAgents).mockReturnValue([agentWithSkill]);
-        vi.mocked(runAgent).mockResolvedValue({ text: "ok", exitCode: 0, stderr: "" });
-        const fs = await import("node:fs");
-        vi.mocked(fs.existsSync).mockImplementation((p) => !String(p).endsWith("ghost-skill"));
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-        const ctx = makeCtx();
-        await pi.tools[0].execute("t", { agent: "scout", task: "x" }, undefined, undefined, ctx);
-        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/skill .*ghost-skill.*not present/), "warning");
-    });
-
-    it("resolves declared skill paths that exist in the package skills dir", async () => {
-        const { discoverAgents } = await import("./discovery.ts");
-        const { runAgent } = await import("./spawn.ts");
-        const agentWithSkill: AgentConfig = { ...sampleAgent, skills: ["playwright-cli"] };
-        vi.mocked(discoverAgents).mockReturnValue([agentWithSkill]);
-        vi.mocked(runAgent).mockResolvedValue({ text: "ok", exitCode: 0, stderr: "" });
-        const fs = await import("node:fs");
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-        await pi.tools[0].execute("t", { agent: "scout", task: "x" }, undefined, undefined, makeCtx());
-        const runAgentCalls = vi.mocked(runAgent).mock.calls;
-        expect(runAgentCalls[0][0].skillPaths).toHaveLength(1);
-    });
-
-    it("agent without color renders plain name in notify", async () => {
-        const noColor: AgentConfig = { ...sampleAgent, color: undefined };
-        const { discoverAgents } = await import("./discovery.ts");
-        const { runAgent } = await import("./spawn.ts");
-        vi.mocked(discoverAgents).mockReturnValue([noColor]);
-        vi.mocked(runAgent).mockResolvedValue({ text: "ok", exitCode: 0, stderr: "" });
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-        const ctx = makeCtx();
-        await pi.tools[0].execute("t", { agent: "scout", task: "x" }, undefined, undefined, ctx);
-        const notifyMsg = ctx.ui.notify.mock.calls[0][0] as string;
-        expect(notifyMsg).toContain("scout");
-    });
-
-    it("agent with unknown color falls back to plain name", async () => {
-        const weirdColor: AgentConfig = { ...sampleAgent, color: "fuchsia-tangerine" };
-        const { discoverAgents } = await import("./discovery.ts");
-        const { runAgent } = await import("./spawn.ts");
-        vi.mocked(discoverAgents).mockReturnValue([weirdColor]);
-        vi.mocked(runAgent).mockResolvedValue({ text: "ok", exitCode: 0, stderr: "" });
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-        const ctx = makeCtx();
-        await pi.tools[0].execute("t", { agent: "scout", task: "x" }, undefined, undefined, ctx);
-        expect(ctx.ui.notify).toHaveBeenCalled();
-    });
-});

package/extensions/astro-agents/index.ts

@@ -1,156 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { Type } from "typebox";
-import { discoverAgents, type AgentScope } from "./discovery.ts";
-import { runAgent } from "./spawn.ts";
-
-const extensionDir = path.dirname(fileURLToPath(import.meta.url));
-const bundleAgentsDir = path.join(extensionDir, "agents");
-const packageSkillsDir = path.resolve(extensionDir, "..", "..", "skills");
-
-function resolvePackageSkills(
-    skillNames: string[],
-    ctx: ExtensionContext,
-): string[] {
-    const resolved: string[] = [];
-    for (const name of skillNames) {
-        const candidate = path.join(packageSkillsDir, name);
-        if (fs.existsSync(candidate)) {
-            resolved.push(candidate);
-        } else {
-            ctx.ui.notify(
-                `skill "${name}" declared by agent is not present in @astrofoundry/pi-astro; skipping.`,
-                "warning",
-            );
-        }
-    }
-    return resolved;
-}
-
-const params = Type.Object({
-    agent: Type.String({ description: "Name of the subagent to invoke." }),
-    task: Type.String({ description: "Task description passed to the subagent." }),
-    scope: Type.Optional(
-        Type.Union(
-            [Type.Literal("user"), Type.Literal("project"), Type.Literal("both")],
-            {
-                description:
-                    "Agent discovery scope. 'user' (default) loads bundled + user-level agents. 'project' requires opt-in and interactive confirmation.",
-            },
-        ),
-    ),
-});
-
-const ANSI_RESET = "\x1b[0m";
-const ANSI_BOLD = "\x1b[1m";
-
-const COLOR_BADGE: Record<string, string> = {
-    red: "\x1b[41m\x1b[97m",
-    orange: "\x1b[48;5;208m\x1b[30m",
-    yellow: "\x1b[43m\x1b[30m",
-    green: "\x1b[42m\x1b[97m",
-    blue: "\x1b[44m\x1b[97m",
-    purple: "\x1b[45m\x1b[97m",
-    magenta: "\x1b[45m\x1b[97m",
-    cyan: "\x1b[46m\x1b[30m",
-    white: "\x1b[47m\x1b[30m",
-    gray: "\x1b[100m\x1b[97m",
-};
-
-function agentBadge(agentName: string, color: string | undefined): string {
-    const key = color?.toLowerCase();
-    const bg = key ? COLOR_BADGE[key] : undefined;
-    if (!bg) return agentName;
-    return `${bg}${ANSI_BOLD} ${agentName} ${ANSI_RESET}`;
-}
-
-const SUBAGENT_STATUS_KEY = "subagents";
-
-export default function astroAgentsExtension(pi: ExtensionAPI): void {
-    let activeAgents = 0;
-
-    function publishCount(ctx: ExtensionContext): void {
-        ctx.ui.setStatus(SUBAGENT_STATUS_KEY, activeAgents > 0 ? String(activeAgents) : undefined);
-    }
-
-    pi.registerTool({
-        name: "astro_agent",
-        label: "Astro Agent",
-        description:
-            "Delegate a task to a named subagent in an isolated pi subprocess. Agents are discovered from bundled (astro-agents/agents/), user-level (~/.pi/agent/agents/), and project-local (.pi/agents/) sources.",
-        parameters: params,
-        async execute(_toolCallId, input, signal, onUpdate, ctx) {
-            const scope: AgentScope = input.scope ?? "user";
-
-            const agents = discoverAgents({
-                cwd: ctx.cwd,
-                bundleDir: bundleAgentsDir,
-                scope,
-            });
-
-            const agent = agents.find((a) => a.name === input.agent);
-            if (!agent) {
-                const available = agents.map((a) => a.name).sort().join(", ") || "none";
-                throw new Error(`Agent "${input.agent}" not found. Available: ${available}.`);
-            }
-
-            if (agent.source === "project" && ctx.hasUI) {
-                const confirmed = await ctx.ui.confirm(
-                    "Run project-local agent?",
-                    `Agent "${agent.name}" is defined in the current project at ${agent.filePath}. Project-local agents can instruct the model to run arbitrary code. Continue?`,
-                );
-                if (!confirmed) {
-                    throw new Error(`User cancelled project-local agent "${agent.name}".`);
-                }
-            }
-
-            ctx.ui.notify(`Running ${agentBadge(agent.name, agent.color)}…`, "info");
-
-            const skillPaths = agent.skills ? resolvePackageSkills(agent.skills, ctx) : [];
-
-            const detailsBase = {
-                agent: agent.name,
-                source: agent.source,
-                color: agent.color,
-            };
-
-            activeAgents++;
-            publishCount(ctx);
-            try {
-                const result = await runAgent({
-                    agent,
-                    task: input.task,
-                    cwd: ctx.cwd,
-                    skillPaths,
-                    signal,
-                    onUpdate: onUpdate
-                        ? (text) => {
-                              onUpdate({
-                                  content: [{ type: "text", text }],
-                                  details: detailsBase,
-                              });
-                          }
-                        : undefined,
-                });
-
-                if (result.exitCode !== 0) {
-                    throw new Error(
-                        `Agent "${agent.name}" exited with code ${result.exitCode}.${result.stderr ? `\nstderr:\n${result.stderr}` : ""}`,
-                    );
-                }
-
-                const text = result.text || "(agent produced no output)";
-
-                return {
-                    content: [{ type: "text", text }],
-                    details: detailsBase,
-                };
-            } finally {
-                activeAgents = Math.max(0, activeAgents - 1);
-                publishCount(ctx);
-            }
-        },
-    });
-}