@schilderlabs/pitown-package 0.2.1

package/pi/extensions/mayor-plan.ts

@@ -0,0 +1,265 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core"
+import type { AssistantMessage, TextContent } from "@mariozechner/pi-ai"
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent"
+import { resolveTownAgentContext } from "#pitown-town-tools"
+
+interface PlanTodo {
+	step: number
+	text: string
+	completed: boolean
+}
+
+interface PersistedMayorPlanState {
+	enabled?: boolean
+	savedTools?: string[]
+	todos?: PlanTodo[]
+}
+
+const PLAN_ALLOWED_TOOLS = new Set(["read", "grep", "find", "ls", "questionnaire", "pitown_board", "pitown_peek_agent"])
+const PLAN_ENTRY_TYPE = "pitown-mayor-plan"
+const PLAN_CONTEXT_TYPE = "pitown-mayor-plan-context"
+const PLAN_CAPTURE_TYPE = "pitown-mayor-plan-captured"
+
+function isAssistantMessage(message: AgentMessage): message is AssistantMessage {
+	return message.role === "assistant" && Array.isArray(message.content)
+}
+
+function getAssistantText(message: AssistantMessage): string {
+	return message.content
+		.filter((block): block is TextContent => block.type === "text")
+		.map((block) => block.text)
+		.join("\n")
+}
+
+function dedupe(values: string[]): string[] {
+	return [...new Set(values)]
+}
+
+function getAllToolNames(pi: ExtensionAPI): string[] {
+	return pi.getAllTools().map((tool) => tool.name)
+}
+
+function resolvePlanTools(candidateTools: string[]): string[] {
+	return dedupe(candidateTools.filter((tool) => PLAN_ALLOWED_TOOLS.has(tool)))
+}
+
+function isMayorSession(ctx: ExtensionContext): boolean {
+	const context = resolveTownAgentContext(ctx.sessionManager.getSessionFile())
+	if (context === null) return false
+	return context.agentId === "leader" || context.role === "leader" || context.role === "mayor"
+}
+
+function persistPlanState(pi: ExtensionAPI, enabled: boolean, savedTools: string[], todos: PlanTodo[]) {
+	pi.appendEntry<PersistedMayorPlanState>(PLAN_ENTRY_TYPE, {
+		enabled,
+		savedTools,
+		todos,
+	})
+}
+
+function extractPlanTodos(text: string): PlanTodo[] {
+	const lines = text.split(/\r?\n/)
+	const startIndex = lines.findIndex((line) => /^plan:\s*$/i.test(line.trim()))
+	const scanFrom = startIndex === -1 ? 0 : startIndex + 1
+	const todos: PlanTodo[] = []
+
+	for (const line of lines.slice(scanFrom)) {
+		const match = line.match(/^\s*(\d+)[.)]\s+(.+?)\s*$/)
+		if (match) {
+			todos.push({
+				step: Number.parseInt(match[1] ?? "0", 10),
+				text: match[2] ?? "",
+				completed: false,
+			})
+			continue
+		}
+
+		if (todos.length > 0 && line.trim() === "") break
+	}
+
+	return todos
+}
+
+function renderTodos(todos: PlanTodo[]): string {
+	if (todos.length === 0) return "No captured plan steps yet. Ask the mayor to produce a numbered Plan: block."
+	return todos.map((todo) => `${todo.step}. ${todo.completed ? "✓" : "○"} ${todo.text}`).join("\n")
+}
+
+function setPlanStatus(ctx: ExtensionContext, enabled: boolean, todos: PlanTodo[]) {
+	if (!ctx.hasUI) return
+	if (!enabled) {
+		ctx.ui.setStatus("pitown-plan", undefined)
+		ctx.ui.setWidget("pitown-plan", undefined)
+		return
+	}
+
+	ctx.ui.setStatus("pitown-plan", ctx.ui.theme.fg("warning", "plan"))
+	ctx.ui.setWidget(
+		"pitown-plan",
+		todos.length === 0 ? ["Mayor plan mode is active."] : todos.map((todo) => `${todo.step}. ${todo.text}`),
+	)
+}
+
+export function registerMayorPlanMode(pi: ExtensionAPI) {
+	let planModeEnabled = false
+	let savedTools: string[] = []
+	let todos: PlanTodo[] = []
+
+	function enablePlanMode(ctx: ExtensionContext) {
+		const currentTools = pi.getActiveTools()
+		const fallbackTools = currentTools.length > 0 ? currentTools : getAllToolNames(pi)
+		if (savedTools.length === 0) savedTools = dedupe(fallbackTools)
+
+		const planTools = resolvePlanTools(savedTools)
+		pi.setActiveTools(planTools)
+		planModeEnabled = true
+		setPlanStatus(ctx, planModeEnabled, todos)
+		persistPlanState(pi, planModeEnabled, savedTools, todos)
+
+		ctx.ui.notify(
+			"Mayor plan mode enabled. Planning is read-only. Use /todos to inspect captured steps and /plan again to leave plan mode.",
+			"info",
+		)
+	}
+
+	function disablePlanMode(ctx: ExtensionContext) {
+		const restoreTools = savedTools.length > 0 ? savedTools : getAllToolNames(pi)
+		pi.setActiveTools(restoreTools)
+		planModeEnabled = false
+		setPlanStatus(ctx, planModeEnabled, todos)
+		persistPlanState(pi, planModeEnabled, savedTools, todos)
+
+		ctx.ui.notify("Mayor plan mode disabled. Delegation and execution tools are available again.", "info")
+	}
+
+	pi.registerFlag("plan", {
+		description: "Start the mayor in read-only planning mode",
+		type: "boolean",
+		default: false,
+	})
+
+	pi.registerCommand("plan", {
+		description: "Toggle mayor planning mode",
+		handler: async (_args, ctx) => {
+			if (!isMayorSession(ctx)) {
+				ctx.ui.notify("/plan is only available in the mayor session.", "warning")
+				return
+			}
+
+			if (planModeEnabled) {
+				disablePlanMode(ctx)
+				return
+			}
+
+			enablePlanMode(ctx)
+		},
+	})
+
+	pi.registerCommand("todos", {
+		description: "Show the mayor's captured plan steps",
+		handler: async (_args, ctx) => {
+			if (!isMayorSession(ctx)) {
+				ctx.ui.notify("/todos is only available in the mayor session.", "warning")
+				return
+			}
+
+			ctx.ui.notify(renderTodos(todos), todos.length === 0 ? "info" : "success")
+		},
+	})
+
+	pi.on("session_start", async (_event, ctx) => {
+		if (!isMayorSession(ctx)) return
+
+		const entry = ctx.sessionManager
+			.getEntries()
+			.filter((candidate: { type: string; customType?: string }) => {
+				return candidate.type === "custom" && candidate.customType === PLAN_ENTRY_TYPE
+			})
+			.pop() as { data?: PersistedMayorPlanState } | undefined
+
+		if (entry?.data?.savedTools) savedTools = dedupe(entry.data.savedTools)
+		if (entry?.data?.todos) todos = entry.data.todos
+		planModeEnabled = entry?.data?.enabled ?? false
+
+		if (pi.getFlag("plan") === true) {
+			planModeEnabled = true
+			if (savedTools.length === 0) {
+				const currentTools = pi.getActiveTools()
+				savedTools = dedupe(currentTools.length > 0 ? currentTools : getAllToolNames(pi))
+			}
+		}
+
+		if (planModeEnabled) {
+			const planTools = resolvePlanTools(savedTools.length > 0 ? savedTools : getAllToolNames(pi))
+			pi.setActiveTools(planTools)
+		}
+
+		setPlanStatus(ctx, planModeEnabled, todos)
+	})
+
+	pi.on("before_agent_start", async (_event, ctx) => {
+		if (!planModeEnabled || !isMayorSession(ctx)) return undefined
+
+		return {
+			message: {
+				customType: PLAN_CONTEXT_TYPE,
+				content: [
+					"[MAYOR PLAN MODE ACTIVE]",
+					"You are planning only.",
+					"Use read-only exploration and Pi Town inspection tools to understand the repo and the current town state.",
+					"Do not delegate work, do not claim that code changes were made, and do not switch into execution.",
+					"Produce a concise numbered plan under a `Plan:` header.",
+					"If the plan depends on active agents, inspect the board first.",
+				].join("\n"),
+				display: false,
+			},
+		}
+	})
+
+	pi.on("tool_call", async (event, ctx) => {
+		if (!planModeEnabled || !isMayorSession(ctx)) return undefined
+
+		if (!PLAN_ALLOWED_TOOLS.has(event.toolName)) {
+			return {
+				block: true,
+				reason: `Mayor plan mode only allows read-only tools. Disable /plan before using ${event.toolName}.`,
+			}
+		}
+
+		if (event.toolName === "pitown_delegate" || event.toolName === "pitown_message_agent" || event.toolName === "pitown_update_status") {
+			return {
+				block: true,
+				reason: `Mayor plan mode blocks orchestration side effects. Disable /plan before using ${event.toolName}.`,
+			}
+		}
+
+		return undefined
+	})
+
+	pi.on("agent_end", async (event, ctx) => {
+		if (!planModeEnabled || !isMayorSession(ctx)) return
+
+		const lastAssistant = [...event.messages].reverse().find(isAssistantMessage)
+		if (!lastAssistant) return
+
+		const extractedTodos = extractPlanTodos(getAssistantText(lastAssistant))
+		if (extractedTodos.length === 0) {
+			persistPlanState(pi, planModeEnabled, savedTools, todos)
+			setPlanStatus(ctx, planModeEnabled, todos)
+			return
+		}
+
+		todos = extractedTodos
+		persistPlanState(pi, planModeEnabled, savedTools, todos)
+		setPlanStatus(ctx, planModeEnabled, todos)
+
+		pi.sendMessage(
+			{
+				customType: PLAN_CAPTURE_TYPE,
+				content: `Plan captured.\n\n${renderTodos(todos)}\n\nStay in /plan to refine it, or run /plan again to leave planning mode and execute through the mayor.`,
+				display: true,
+			},
+			{ triggerTurn: false },
+		)
+	})
+}

package/pi/extensions/require-tests/index.test.ts

@@ -0,0 +1,119 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent"
+import { describe, expect, it, vi } from "vitest"
+
+import requireTestsExtension from "./index"
+
+type RegisteredHandler = (event: unknown, ctx: unknown) => unknown | Promise<unknown>
+
+function setup() {
+	const handlers: Record<string, RegisteredHandler[]> = {}
+	const pi = {
+		on: vi.fn((event: string, handler: RegisteredHandler) => {
+			;(handlers[event] ??= []).push(handler)
+		}),
+		sendMessage: vi.fn(),
+	} as unknown as ExtensionAPI & {
+		sendMessage: ReturnType<typeof vi.fn>
+	}
+
+	requireTestsExtension(pi)
+
+	return {
+		handlers,
+		pi,
+	}
+}
+
+describe("require-tests extension", () => {
+	it("queues a follow-up when implementation files change without tests", async () => {
+		const { handlers, pi } = setup()
+
+		await handlers["agent_start"]?.[0]?.({}, {})
+		await handlers["tool_result"]?.[0]?.(
+			{
+				toolName: "edit",
+				input: { path: "src/domain/create-widget.ts" },
+				content: [],
+				details: undefined,
+				isError: false,
+			},
+			{},
+		)
+		await handlers["agent_end"]?.[0]?.({ messages: [] }, {})
+
+		expect(pi.sendMessage).toHaveBeenCalledWith(
+			expect.objectContaining({
+				customType: "require-tests",
+				display: true,
+				content: expect.stringContaining("src/domain/create-widget.ts"),
+			}),
+			expect.objectContaining({ triggerTurn: true }),
+		)
+	})
+
+	it("does not queue a follow-up when a test file changes in the same prompt", async () => {
+		const { handlers, pi } = setup()
+
+		await handlers["agent_start"]?.[0]?.({}, {})
+		await handlers["tool_result"]?.[0]?.(
+			{
+				toolName: "write",
+				input: { path: "src/domain/create-widget.ts" },
+				content: [],
+				details: undefined,
+				isError: false,
+			},
+			{},
+		)
+		await handlers["tool_result"]?.[0]?.(
+			{
+				toolName: "write",
+				input: { path: "src/domain/create-widget.test.ts" },
+				content: [],
+				details: undefined,
+				isError: false,
+			},
+			{},
+		)
+		await handlers["agent_end"]?.[0]?.({ messages: [] }, {})
+
+		expect(pi.sendMessage).not.toHaveBeenCalled()
+	})
+
+	it("does not queue a follow-up for UI-only changes", async () => {
+		const { handlers, pi } = setup()
+
+		await handlers["agent_start"]?.[0]?.({}, {})
+		await handlers["tool_result"]?.[0]?.(
+			{
+				toolName: "edit",
+				input: { path: "apps/native/src/screens/SettingsScreen.tsx" },
+				content: [],
+				details: undefined,
+				isError: false,
+			},
+			{},
+		)
+		await handlers["agent_end"]?.[0]?.({ messages: [] }, {})
+
+		expect(pi.sendMessage).not.toHaveBeenCalled()
+	})
+
+	it("injects a hidden reminder before each agent run", async () => {
+		const { handlers } = setup()
+
+		const result = await handlers["before_agent_start"]?.[0]?.(
+			{ systemPrompt: "base", prompt: "do work", images: [] },
+			{},
+		)
+
+		expect(result).toEqual(
+			expect.objectContaining({
+				message: expect.objectContaining({
+					customType: "require-tests",
+					display: false,
+				}),
+			}),
+		)
+	})
+})

package/pi/extensions/require-tests/index.ts

@@ -0,0 +1,106 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent"
+import { isEditToolResult, isWriteToolResult } from "@mariozechner/pi-coding-agent"
+
+const TEST_FILE_PATTERN = /(^|\/)(__tests__|tests?)\/|\.(test|spec)\.[^.]+$/i
+const UI_DIRECTORY_PATTERNS = [/^apps\/native\//i, /^packages\/frontend-native\//i, /^packages\/ui-native\//i]
+const UI_FILE_PATTERN = /\.(tsx|jsx)$/i
+const IMPLEMENTATION_FILE_PATTERN = /\.(c|m)?(t|j)sx?$|\.(py|rb|go|rs|java|kt|swift)$/i
+
+export interface ModifiedFileAnalysis {
+	modifiedFiles: string[]
+	implementationFiles: string[]
+	testFiles: string[]
+	requiresTests: boolean
+	hasRequiredTests: boolean
+}
+
+export function normalizeFilePath(filePath: string): string {
+	return filePath.replace(/^@/, "").replace(/\\/g, "/")
+}
+
+export function isTestFile(filePath: string): boolean {
+	return TEST_FILE_PATTERN.test(normalizeFilePath(filePath))
+}
+
+export function isUiOnlyFile(filePath: string): boolean {
+	const normalizedPath = normalizeFilePath(filePath)
+	return UI_FILE_PATTERN.test(normalizedPath) || UI_DIRECTORY_PATTERNS.some((pattern) => pattern.test(normalizedPath))
+}
+
+export function isImplementationFile(filePath: string): boolean {
+	const normalizedPath = normalizeFilePath(filePath)
+	if (!IMPLEMENTATION_FILE_PATTERN.test(normalizedPath)) return false
+	if (isTestFile(normalizedPath)) return false
+	if (isUiOnlyFile(normalizedPath)) return false
+	if (normalizedPath.endsWith(".d.ts")) return false
+	return true
+}
+
+export function analyzeModifiedFiles(files: Iterable<string>): ModifiedFileAnalysis {
+	const modifiedFiles = [...new Set(Array.from(files, normalizeFilePath))]
+	const implementationFiles = modifiedFiles.filter(isImplementationFile)
+	const testFiles = modifiedFiles.filter(isTestFile)
+
+	return {
+		modifiedFiles,
+		implementationFiles,
+		testFiles,
+		requiresTests: implementationFiles.length > 0,
+		hasRequiredTests: testFiles.length > 0,
+	}
+}
+
+function buildReminderMessage(implementationFiles: string[]): string {
+	const changedFiles = implementationFiles.map((filePath) => `- ${filePath}`).join("\n")
+
+	return [
+		"Test guard: you changed implementation code without also updating tests.",
+		"",
+		"Changed implementation files:",
+		changedFiles,
+		"",
+		"Before finishing, write or update tests that verify behavior through public interfaces.",
+		"Prefer integration-style tests that describe what the system does and can survive refactors.",
+	].join("\n")
+}
+
+export default function requireTestsExtension(pi: ExtensionAPI) {
+	let modifiedFiles = new Set<string>()
+
+	pi.on("before_agent_start", async () => ({
+		message: {
+			customType: "require-tests",
+			content:
+				"If you modify non-UI implementation files, also add or update tests in the same turn. UI-only TSX/JSX changes and files under apps/native, packages/frontend-native, or packages/ui-native are exempt.",
+			display: false,
+		},
+	}))
+
+	pi.on("agent_start", async () => {
+		modifiedFiles = new Set<string>()
+	})
+
+	pi.on("tool_result", async (event) => {
+		if (event.isError) return
+		if (!isEditToolResult(event) && !isWriteToolResult(event)) return
+
+		const filePath = event.input["path"]
+		if (typeof filePath !== "string") return
+
+		modifiedFiles.add(normalizeFilePath(filePath))
+	})
+
+	pi.on("agent_end", async () => {
+		const analysis = analyzeModifiedFiles(modifiedFiles)
+		if (!analysis.requiresTests || analysis.hasRequiredTests) return
+
+		pi.sendMessage(
+			{
+				customType: "require-tests",
+				content: buildReminderMessage(analysis.implementationFiles),
+				display: true,
+			},
+			{ triggerTurn: true },
+		)
+	})
+}