@agnishc/edb-subagents 0.10.8 → 0.10.9

package/CHANGELOG.md

@@ -1,5 +1,7 @@
 # Changelog
 
+## [0.10.9] - 2026-05-18
+
 ## [0.10.8] - 2026-05-18
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agnishc/edb-subagents",
-	"version": "0.10.8",
+	"version": "0.10.9",
 	"description": "Pi extension: Claude Code-style autonomous sub-agents with live widget, parallel execution, mid-run steering, and custom agent types",
 	"keywords": [
 		"pi-package",

package/src/agent-types.test.ts

@@ -0,0 +1,126 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { getAgentConfig, getAvailableTypes, getToolNamesForType, registerAgents, resolveType } from "./agent-types.js";
+import type { AgentConfig } from "./types.js";
+
+describe("agent-types registry", () => {
+	beforeEach(() => {
+		// Reset registry by re-registering empty map
+		registerAgents(new Map());
+	});
+
+	it("registerAgents adds types to registry", () => {
+		const config: AgentConfig = {
+			name: "test",
+			description: "Test agent",
+			model: "test/model",
+			extensions: true,
+			skills: true,
+			promptMode: "append",
+			systemPrompt: "Test",
+		};
+		registerAgents(new Map([["test", config]]));
+		expect(getAvailableTypes()).toContain("test");
+	});
+
+	it("resolveType returns config for registered type", () => {
+		const config: AgentConfig = {
+			name: "coder",
+			description: "Coder agent",
+			model: "test/model",
+			extensions: true,
+			skills: true,
+			promptMode: "append",
+			systemPrompt: "You are a coder",
+		};
+		registerAgents(new Map([["coder", config]]));
+		const resolved = resolveType("coder");
+		expect(resolved).toBe("coder");
+	});
+
+	it("resolveType is case-insensitive", () => {
+		const config: AgentConfig = {
+			name: "Coder",
+			description: "Coder",
+			model: "m",
+			extensions: true,
+			skills: true,
+			promptMode: "append",
+			systemPrompt: "Test",
+		};
+		registerAgents(new Map([["Coder", config]]));
+		expect(resolveType("CODER")).toBe("Coder");
+		expect(resolveType("coder")).toBe("Coder");
+	});
+
+	it("resolveType returns undefined for unknown type", () => {
+		registerAgents(new Map());
+		expect(resolveType("nonexistent")).toBeUndefined();
+	});
+
+	it("getAgentConfig returns config for registered type", () => {
+		const config: AgentConfig = {
+			name: "reviewer",
+			description: "Reviewer",
+			model: "test/model",
+			extensions: true,
+			skills: true,
+			promptMode: "append",
+			systemPrompt: "You are a reviewer",
+		};
+		registerAgents(new Map([["reviewer", config]]));
+		const result = getAgentConfig("reviewer");
+		expect(result?.name).toBe("reviewer");
+	});
+
+	it("getAgentConfig returns undefined for unknown type", () => {
+		registerAgents(new Map());
+		expect(getAgentConfig("nonexistent")).toBeUndefined();
+	});
+
+	it("getAvailableTypes excludes disabled agents", () => {
+		const config: AgentConfig = {
+			name: "disabled",
+			description: "Disabled",
+			model: "test/model",
+			enabled: false,
+			extensions: true,
+			skills: true,
+			promptMode: "append",
+			systemPrompt: "Disabled",
+		};
+		registerAgents(new Map([["disabled", config]]));
+		expect(getAvailableTypes()).not.toContain("disabled");
+	});
+
+	it("getToolNamesForType returns tools for registered type", () => {
+		const config: AgentConfig = {
+			name: "coder",
+			description: "Coder",
+			model: "m",
+			builtinToolNames: ["read", "write", "bash"],
+			extensions: true,
+			skills: true,
+			promptMode: "append",
+			systemPrompt: "Test",
+		};
+		registerAgents(new Map([["coder", config]]));
+		const tools = getToolNamesForType("coder");
+		expect(tools).toContain("read");
+		expect(tools).toContain("write");
+	});
+
+	it("getToolNamesForType returns default tools when not specified", () => {
+		const config: AgentConfig = {
+			name: "custom",
+			description: "Custom",
+			model: "m",
+			extensions: true,
+			skills: true,
+			promptMode: "append",
+			systemPrompt: "Test",
+		};
+		registerAgents(new Map([["custom", config]]));
+		const tools = getToolNamesForType("custom");
+		expect(tools).toContain("read");
+	});
+});

package/src/memory.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { isUnsafeName } from "./memory.js";
+
+describe("isUnsafeName", () => {
+	it("returns false for safe names", () => {
+		expect(isUnsafeName("index")).toBe(false);
+		expect(isUnsafeName("index.ts")).toBe(false);
+		expect(isUnsafeName("my-agent")).toBe(false);
+		expect(isUnsafeName("my_agent_123")).toBe(false);
+		expect(isUnsafeName("Agent2")).toBe(false);
+	});
+
+	it("returns true for empty name", () => {
+		expect(isUnsafeName("")).toBe(true);
+	});
+
+	it("returns true for names over 128 chars", () => {
+		expect(isUnsafeName("a".repeat(129))).toBe(true);
+	});
+
+	it("returns true for names starting with dot", () => {
+		expect(isUnsafeName(".git")).toBe(true);
+		expect(isUnsafeName(".DS_Store")).toBe(true);
+	});
+
+	it("allows underscores in safe names", () => {
+		// The regex allows underscores, so node_modules is technically "safe"
+		expect(isUnsafeName("node_modules")).toBe(false);
+		expect(isUnsafeName("my_agent")).toBe(false);
+	});
+
+	it("returns true for names with special characters", () => {
+		expect(isUnsafeName("agent@home")).toBe(true);
+		expect(isUnsafeName("agent space")).toBe(true);
+	});
+
+	it("returns true for leading hyphen", () => {
+		expect(isUnsafeName("-agent")).toBe(true);
+	});
+});

package/src/prompts.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { buildAgentPrompt } from "./prompts.js";
+import type { AgentConfig } from "./types.js";
+
+describe("buildAgentPrompt", () => {
+	const baseConfig: AgentConfig = {
+		name: "Test Agent",
+		description: "Test agent",
+		extensions: true,
+		skills: true,
+		promptMode: "replace",
+		systemPrompt: "You are a test agent.",
+	};
+
+	const baseEnv = {
+		cwd: "/tmp/test",
+		platform: "darwin",
+		isGitRepo: false,
+		branch: "",
+	};
+
+	it("includes active_agent tag", () => {
+		const result = buildAgentPrompt(baseConfig, baseEnv.cwd, baseEnv);
+		expect(result).toContain('<active_agent name="Test Agent"/>');
+	});
+
+	it("includes environment info", () => {
+		const result = buildAgentPrompt(baseConfig, "/tmp/test", baseEnv);
+		expect(result).toContain("Working directory: /tmp/test");
+	});
+
+	it("includes platform in replace mode", () => {
+		const result = buildAgentPrompt(baseConfig, "/tmp/test", baseEnv);
+		expect(result).toContain("Platform: darwin");
+	});
+
+	it("includes system prompt in replace mode", () => {
+		const result = buildAgentPrompt(baseConfig, "/tmp/test", baseEnv);
+		expect(result).toContain("You are a test agent.");
+	});
+
+	it("includes git info when in git repo", () => {
+		const env = { ...baseEnv, isGitRepo: true, branch: "main" };
+		const result = buildAgentPrompt(baseConfig, "/tmp/test", env);
+		expect(result).toContain("Git repository: yes");
+		expect(result).toContain("Branch: main");
+	});
+
+	it("includes parent system prompt in append mode", () => {
+		const config: AgentConfig = { ...baseConfig, promptMode: "append" };
+		const result = buildAgentPrompt(config, "/tmp/test", baseEnv, "You are the parent.");
+		expect(result).toContain("You are the parent.");
+	});
+
+	it("includes agent instructions in append mode", () => {
+		const config: AgentConfig = { ...baseConfig, promptMode: "append" };
+		const result = buildAgentPrompt(config, "/tmp/test", baseEnv);
+		expect(result).toContain("<agent_instructions>");
+	});
+
+	it("includes memory block when provided", () => {
+		const result = buildAgentPrompt(baseConfig, "/tmp/test", baseEnv, undefined, {
+			memoryBlock: "# Memory\nPrevious work: done",
+		});
+		expect(result).toContain("Memory");
+		expect(result).toContain("Previous work: done");
+	});
+
+	it("includes skill blocks when provided", () => {
+		const result = buildAgentPrompt(baseConfig, "/tmp/test", baseEnv, undefined, {
+			skillBlocks: [{ name: "TestSkill", content: "Test content" }],
+		});
+		expect(result).toContain("Preloaded Skill: TestSkill");
+		expect(result).toContain("Test content");
+	});
+});

package/src/usage.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import type { LifetimeUsage } from "./usage.js";
+import { getLifetimeTotal, getSessionContextPercent, getSessionTokens } from "./usage.js";
+
+describe("getLifetimeTotal", () => {
+	it("returns 0 when undefined", () => {
+		expect(getLifetimeTotal(undefined)).toBe(0);
+	});
+
+	it("sums tokens from usage object", () => {
+		const usage: LifetimeUsage = { input: 100, output: 200, cacheWrite: 50 };
+		expect(getLifetimeTotal(usage)).toBe(350);
+	});
+
+	it("handles single component", () => {
+		const usage: LifetimeUsage = { input: 500, output: 0, cacheWrite: 0 };
+		expect(getLifetimeTotal(usage)).toBe(500);
+	});
+});
+
+describe("getSessionTokens", () => {
+	it("returns 0 for undefined session", () => {
+		expect(getSessionTokens(undefined)).toBe(0);
+	});
+
+	it("returns 0 when getSessionStats throws", () => {
+		const badSession = {
+			getSessionStats: () => {
+				throw new Error("no stats");
+			},
+		};
+		expect(getSessionTokens(badSession as any)).toBe(0);
+	});
+
+	it("sums tokens from session stats", () => {
+		const session = {
+			getSessionStats: () => ({
+				tokens: { input: 100, output: 200, cacheWrite: 50 },
+			}),
+		};
+		expect(getSessionTokens(session as any)).toBe(350);
+	});
+});
+
+describe("getSessionContextPercent", () => {
+	it("returns null for undefined session", () => {
+		expect(getSessionContextPercent(undefined)).toBeNull();
+	});
+
+	it("returns null when getSessionStats throws", () => {
+		const badSession = {
+			getSessionStats: () => {
+				throw new Error("no stats");
+			},
+		};
+		expect(getSessionContextPercent(badSession as any)).toBeNull();
+	});
+
+	it("returns context percent from session stats", () => {
+		const session = {
+			getSessionStats: () => ({
+				tokens: { input: 100, output: 200, cacheWrite: 0 },
+				contextUsage: { percent: 75 },
+			}),
+		};
+		expect(getSessionContextPercent(session as any)).toBe(75);
+	});
+
+	it("returns null when percent is missing", () => {
+		const session = {
+			getSessionStats: () => ({
+				tokens: { input: 100, output: 200, cacheWrite: 0 },
+			}),
+		};
+		expect(getSessionContextPercent(session as any)).toBeNull();
+	});
+});