moonpi 0.4.2

package/src/guards.ts

@@ -0,0 +1,101 @@
+import { existsSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, relative, resolve } from "node:path";
+import type { ExtensionAPI, ToolCallEvent, ToolResultEvent } from "@mariozechner/pi-coding-agent";
+import type { MoonpiController } from "./modes.js";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function expandPath(filePath: string): string {
+  if (filePath === "~") return homedir();
+  if (filePath.startsWith("~/")) return resolve(homedir(), filePath.slice(2));
+  return filePath.startsWith("@") ? filePath.slice(1) : filePath;
+}
+
+function normalizePath(filePath: string, cwd: string): string {
+  const expanded = expandPath(filePath);
+  const absolute = isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded);
+  return existsSync(absolute) ? realpathSync(absolute) : absolute;
+}
+
+function isInsideDir(filePath: string, dir: string): boolean {
+  const dirReal = existsSync(dir) ? realpathSync(dir) : resolve(dir);
+  const target = normalizePath(filePath, dirReal);
+  const rel = relative(dirReal, target);
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+function isInsideCwd(filePath: string, cwd: string): boolean {
+  return isInsideDir(filePath, cwd);
+}
+
+function isInAllowedPath(filePath: string, cwd: string, allowedPaths: string[]): boolean {
+  for (const allowed of allowedPaths) {
+    const expanded = expandPath(allowed);
+    const absolute = isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded);
+    if (isInsideDir(filePath, absolute)) return true;
+  }
+  return false;
+}
+
+function pathFromToolCall(event: ToolCallEvent): string | undefined {
+  const input: Record<string, unknown> = isRecord(event.input) ? (event.input as Record<string, unknown>) : {};
+  const value = input.path;
+  if (typeof value === "string") return value;
+  return undefined;
+}
+
+function shouldCheckPath(toolName: string): boolean {
+  return toolName === "read" || toolName === "write" || toolName === "edit" || toolName === "grep" || toolName === "find" || toolName === "ls";
+}
+
+function shouldRequirePriorRead(toolName: string): boolean {
+  return toolName === "write" || toolName === "edit";
+}
+
+function shouldBlockInPlanPhase(toolName: string): boolean {
+  return toolName === "bash" || toolName === "write" || toolName === "edit";
+}
+
+export function installGuards(pi: ExtensionAPI, controller: MoonpiController): void {
+  pi.on("tool_call", async (event, ctx) => {
+    if (controller.isPlanPhase() && shouldBlockInPlanPhase(event.toolName)) {
+      const allowedTools = controller.isQuestionAllowed() ? "read, grep, find, ls, todo, or question" : "read, grep, find, ls, or todo";
+      return {
+        block: true,
+        reason: `moonpi blocked ${event.toolName}: the current Moonpi phase is read-only. Use ${allowedTools} instead.`,
+      };
+    }
+
+    if (!shouldCheckPath(event.toolName)) return undefined;
+    const rawPath = pathFromToolCall(event) ?? ".";
+
+    if (controller.config.guards.cwdOnly && !isInsideCwd(rawPath, ctx.cwd) && !isInAllowedPath(rawPath, ctx.cwd, controller.config.guards.allowedPaths)) {
+      return {
+        block: true,
+        reason: `moonpi blocked ${event.toolName}: path is outside the current working directory and allowed paths: ${rawPath}`,
+      };
+    }
+
+    if (!controller.config.guards.readBeforeWrite || !shouldRequirePriorRead(event.toolName)) return undefined;
+    const absolute = normalizePath(rawPath, ctx.cwd);
+    if (!existsSync(absolute)) return undefined;
+    if (controller.state.hasRead(absolute)) return undefined;
+
+    return {
+      block: true,
+      reason: `moonpi blocked ${event.toolName}: read the file first before modifying it: ${rawPath}`,
+    };
+  });
+
+  pi.on("tool_result", async (event: ToolResultEvent, ctx) => {
+    if (event.toolName !== "read" || event.isError) return undefined;
+    const rawPath = typeof event.input.path === "string" ? event.input.path : undefined;
+    if (!rawPath) return undefined;
+    controller.state.markRead(normalizePath(rawPath, ctx.cwd));
+    controller.persist();
+    return undefined;
+  });
+}

package/src/index.ts

@@ -0,0 +1,145 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { formatConfig } from "./config.js";
+import { installContextFiles } from "./context-files.js";
+import { installGuards } from "./guards.js";
+import { MoonpiController } from "./modes.js";
+import { formatTodoList } from "./state.js";
+import { installSprintWorkflow } from "./sprint.js";
+import { installSynthetic } from "./synthetic.js";
+import { installMoonpiTools } from "./tools.js";
+import type { MoonpiMode } from "./types.js";
+
+const MODES: MoonpiMode[] = ["plan", "act", "auto", "fast"];
+
+function isMoonpiMode(value: string): value is MoonpiMode {
+  return value === "plan" || value === "act" || value === "auto" || value === "fast" || value === "sprint:plan" || value === "sprint:act";
+}
+
+export default async function moonpi(pi: ExtensionAPI): Promise<void> {
+  const controller = new MoonpiController(pi);
+
+  installMoonpiTools(pi, controller);
+  installGuards(pi, controller);
+  installContextFiles(pi, controller);
+  installSprintWorkflow(pi, controller);
+
+  pi.registerCommand("moonpi:mode", {
+    description: "Switch moonpi mode: plan, act, auto, fast",
+    getArgumentCompletions: (prefix) => {
+      return MODES.filter((mode) => mode.startsWith(prefix)).map((mode) => ({ label: mode, value: mode }));
+    },
+    handler: async (args, ctx) => {
+      const requested = args.trim();
+      if (!requested) {
+        const selectable = MODES; // MODES only contains user-selectable modes, not sprint:plan/sprint:act
+        const selected = await ctx.ui.select("moonpi mode", [...selectable]);
+        if (selected && isMoonpiMode(selected)) controller.setMode(ctx, selected);
+        return;
+      }
+      if (!isMoonpiMode(requested)) {
+        ctx.ui.notify(`Unknown moonpi mode: ${requested}`, "error");
+        return;
+      }
+      if (requested === "sprint:plan" || requested === "sprint:act") {
+        ctx.ui.notify(`Mode ${requested} cannot be set manually. It is managed by the sprint loop.`, "error");
+        return;
+      }
+      controller.setMode(ctx, requested);
+    },
+  });
+
+  pi.registerCommand("moonpi:settings", {
+    description: "Show effective moonpi settings",
+    handler: async (_args, ctx) => {
+      ctx.ui.notify(formatConfig(controller.config), "info");
+    },
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    controller.restoreFromSession(ctx);
+    controller.installUi(ctx);
+    controller.applyMode(ctx);
+  });
+
+  pi.on("session_tree", async (_event, ctx) => {
+    controller.restoreFromSession(ctx);
+    controller.applyMode(ctx);
+  });
+
+  pi.on("session_shutdown", async () => {
+    controller.disposeUi();
+  });
+
+  pi.on("input", async (event, ctx) => {
+    if (event.source !== "extension") controller.resetForUserPrompt(ctx);
+    return { action: "continue" };
+  });
+
+  pi.on("before_agent_start", async (event) => {
+    return {
+      systemPrompt: `${event.systemPrompt}
+
+You are moonpi.
+
+${controller.buildModePrompt()}`,
+    };
+  });
+
+  pi.on("agent_end", async (_event, ctx) => {
+    controller.updateUi(ctx);
+
+    const isPlanMode = controller.state.mode === "plan" || controller.state.mode === "sprint:plan";
+    if (isPlanMode && controller.state.todos.length === 0) {
+      setImmediate(() => {
+        pi.sendUserMessage(
+          "Moonpi Plan mode requires a TODO list before the turn can finish. Use todo to create the plan now.",
+        );
+      });
+      return;
+    }
+
+    // sprint:act completed → back to sprint:plan
+    if (controller.state.mode === "sprint:act") {
+      controller.state.setMode("sprint:plan");
+      controller.state.todos = [];
+      controller.state.nextTodoId = 1;
+      controller.applyMode(ctx);
+      controller.persist();
+      return;
+    }
+
+    // sprint:plan completed with TODOs → switch to sprint:act
+    if (controller.state.mode === "sprint:plan" && controller.state.todos.length > 0) {
+      controller.state.setMode("sprint:act");
+      controller.applyMode(ctx);
+      controller.persist();
+      setImmediate(() => {
+        pi.sendUserMessage("Moonpi Sprint mode is switching to Act phase. Execute the TODO list now.");
+      });
+      return;
+    }
+
+    if (controller.state.mode !== "auto" || controller.state.autoPhase !== "plan") return;
+    if (controller.state.endConversationRequested) {
+      controller.state.endConversationRequested = false;
+      controller.persist();
+      return;
+    }
+    if (controller.state.todos.length === 0) return;
+
+    controller.switchAutoToAct(ctx);
+    setImmediate(() => {
+      const todoList = formatTodoList(controller.state.todos);
+      pi.sendUserMessage(`Auto mode is switching to Act phase. Execute the TODO list now.
+
+${todoList}`);
+    });
+  });
+
+  // Synthetic is optional; keep core Moonpi mode hooks installed even if provider setup fails.
+  try {
+    await installSynthetic(pi);
+  } catch {
+    // Ignore optional provider setup failures.
+  }
+}

package/src/modes.ts

@@ -0,0 +1,233 @@
+import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@mariozechner/pi-coding-agent";
+import type { KeyId } from "@mariozechner/pi-tui";
+import { matchesKey } from "@mariozechner/pi-tui";
+import { loadMoonpiConfig } from "./config.js";
+import { MoonpiState, formatTodoList } from "./state.js";
+import type { MoonpiConfig, MoonpiMode, MoonpiSnapshot } from "./types.js";
+import { installMoonpiEditor, installMoonpiHeader } from "./ui.js";
+
+const MODE_ORDER: MoonpiMode[] = ["plan", "act", "auto", "fast"];
+const STABLE_MOONPI_TOOLS = [
+  "read",
+  "grep",
+  "find",
+  "ls",
+  "bash",
+  "edit",
+  "write",
+  "todo",
+  "question",
+  "end_conversation",
+  "end_phase",
+];
+const MOONPI_TOOL_NAMES = new Set(STABLE_MOONPI_TOOLS);
+type Direction = "next" | "previous";
+
+function entryHasMoonpiSnapshot(entry: SessionEntry): entry is SessionEntry & { customType: "moonpi-state"; data: MoonpiSnapshot } {
+  if (entry.type !== "custom") return false;
+  const candidate = entry as SessionEntry & { customType?: string; data?: unknown };
+  return candidate.customType === "moonpi-state" && typeof candidate.data === "object" && candidate.data !== null;
+}
+
+function latestSnapshot(entries: SessionEntry[]): MoonpiSnapshot | undefined {
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    if (entry && entryHasMoonpiSnapshot(entry)) return entry.data;
+  }
+  return undefined;
+}
+
+export class MoonpiController {
+  readonly state = new MoonpiState();
+  config: MoonpiConfig = loadMoonpiConfig(process.cwd());
+  private terminalInputUnsubscribe: (() => void) | undefined;
+
+  constructor(private readonly pi: ExtensionAPI) {}
+
+  restoreFromSession(ctx: ExtensionContext): void {
+    this.config = loadMoonpiConfig(ctx.cwd);
+    this.state.mode = this.config.defaultMode;
+    this.state.restore(latestSnapshot(ctx.sessionManager.getEntries()));
+  }
+
+  persist(): void {
+    this.pi.appendEntry("moonpi-state", this.state.snapshot());
+  }
+
+  setMode(ctx: ExtensionContext, mode: MoonpiMode): void {
+    this.state.setMode(mode);
+    this.applyMode(ctx);
+    this.persist();
+    ctx.ui.notify(`moonpi mode: ${mode}`, "info");
+  }
+
+  cycleMode(ctx: ExtensionContext, direction: Direction): void {
+    const currentIndex = MODE_ORDER.indexOf(this.state.mode);
+    const offset = direction === "next" ? 1 : -1;
+    const nextIndex = (currentIndex + offset + MODE_ORDER.length) % MODE_ORDER.length;
+    const nextMode = MODE_ORDER[nextIndex] ?? "auto";
+    this.setMode(ctx, nextMode);
+  }
+
+  resetForUserPrompt(ctx: ExtensionContext): void {
+    this.state.resetForUserPrompt();
+    this.applyMode(ctx);
+    this.persist();
+  }
+
+  markEndConversationRequested(): void {
+    this.state.endConversationRequested = true;
+    this.persist();
+  }
+
+  switchAutoToAct(ctx: ExtensionContext): void {
+    this.state.autoPhase = "act";
+    this.applyMode(ctx);
+    this.persist();
+  }
+
+  applyMode(ctx: ExtensionContext): void {
+    this.pi.setActiveTools(this.getToolsForCurrentMode());
+    this.updateUi(ctx);
+  }
+
+  isPlanPhase(): boolean {
+    return this.state.mode === "plan" || this.state.mode === "sprint:plan" || (this.state.mode === "auto" && this.state.autoPhase === "plan");
+  }
+
+  isQuestionAllowed(): boolean {
+    return this.state.mode !== "fast" && this.state.mode !== "sprint:plan" && this.state.mode !== "sprint:act";
+  }
+
+  isEndConversationAllowed(): boolean {
+    return this.state.mode === "auto" && this.state.autoPhase === "plan";
+  }
+
+  installUi(ctx: ExtensionContext): void {
+    installMoonpiHeader(ctx);
+    if (this.config.customEditor) {
+      installMoonpiEditor(ctx, () => this.state.mode);
+    }
+    this.terminalInputUnsubscribe?.();
+    this.terminalInputUnsubscribe = ctx.ui.onTerminalInput((data) => {
+      if (ctx.ui.getEditorText().length > 0) return undefined;
+      if (matchesKey(data, this.config.keybindings.cycleNext as KeyId)) {
+        this.cycleMode(ctx, "next");
+        return { consume: true };
+      }
+      if (matchesKey(data, this.config.keybindings.cyclePrevious as KeyId)) {
+        this.cycleMode(ctx, "previous");
+        return { consume: true };
+      }
+      return undefined;
+    });
+  }
+
+  disposeUi(): void {
+    this.terminalInputUnsubscribe?.();
+    this.terminalInputUnsubscribe = undefined;
+  }
+
+  updateUi(ctx: ExtensionContext): void {
+    const isSprint = this.state.mode === "sprint:plan" || this.state.mode === "sprint:act";
+    const phase = this.state.mode === "auto" ? `:${this.state.autoPhase}` : isSprint ? `:${this.state.mode === "sprint:act" ? "act" : "plan"}` : "";
+    const modeLabel = isSprint ? "sprint" : this.state.mode;
+    const total = this.state.todos.length;
+    const done = this.state.todos.filter((todo) => todo.status === "done").length;
+    ctx.ui.setStatus("moonpi", ctx.ui.theme.fg("accent", `moonpi ${modeLabel}${phase} ${done}/${total}`));
+
+    if (this.state.mode === "fast" || total === 0) {
+      ctx.ui.setWidget("moonpi-todos", undefined);
+      return;
+    }
+    ctx.ui.setWidget("moonpi-todos", formatTodoList(this.state.todos).split("\n"), { placement: "aboveEditor" });
+  }
+
+  getToolsForCurrentMode(): string[] {
+    if (!this.config.preserveExternalTools) return STABLE_MOONPI_TOOLS;
+    const externalTools = this.pi.getActiveTools().filter((toolName) => !MOONPI_TOOL_NAMES.has(toolName));
+    return [...new Set([...STABLE_MOONPI_TOOLS, ...externalTools])];
+  }
+
+  buildModePrompt(): string {
+    if (this.state.mode === "auto") return AUTO_MODE_PROMPT;
+    if (this.state.mode === "plan") return PLAN_MODE_PROMPT;
+    if (this.state.mode === "act") return ACT_MODE_PROMPT;
+    if (this.state.mode === "fast") return FAST_MODE_PROMPT;
+    if (this.state.mode === "sprint:plan") return SPRINT_PLAN_MODE_PROMPT;
+    return SPRINT_ACT_MODE_PROMPT;
+  }
+}
+
+const PLAN_MODE_PROMPT = `## Plan Mode
+
+You are in Plan mode. This mode is for investigation and planning before implementation.
+
+- Use read, grep, find, and ls to inspect the project.
+- Do not use bash, edit, or write; The system blocks those tools in this mode.
+- Ask concise clarifying questions with question when a user decision is required.
+- Create or update a concrete TODO list with todo before ending the turn.
+- Do not implement changes in Plan mode. The TODO list should make the next Act-mode work explicit.`;
+
+const ACT_MODE_PROMPT = `## Act Mode
+
+You are in Act mode. This mode is for implementation.
+
+- Use read, grep, find, ls, bash, edit, and write as needed.
+- Use todo when it helps track progress, especially when executing a plan created earlier.
+- Ask questions only when blocked by a real user decision.
+- Keep changes scoped to the user's request and verify the result when practical.`;
+
+const AUTO_MODE_PROMPT = `## Auto Mode
+
+Auto mode uses this same system prompt for both Plan and Act phases. The system prompt must not change when Auto advances from Plan to Act, so the conversation can keep provider prompt-cache affinity.
+
+Auto begins in Plan phase. In Plan phase:
+
+- Use read, grep, find, and ls to inspect the project.
+- Do not use bash, edit, or write; The system blocks those tools until Act phase.
+- If the request needs implementation, create a concrete non-empty TODO list with todo.
+- If the user only asked a question or no action is needed, call end_conversation instead of creating TODOs.
+
+Creating or updating a non-empty TODO list ends Auto planning. The system then retains the conversation, switches runtime to Act phase, and sends this user message:
+
+Auto mode is switching to Act phase. Execute the TODO list now.
+
+#1 [ ] First task
+#2 [ ] Second task
+...
+
+That user message is the phase-change signal. After you see it, you are in Act phase:
+
+- Execute the TODO list.
+- Use read, grep, find, ls, bash, edit, and write as needed.
+- Update TODO statuses with todo as work progresses.
+- Ask questions only when blocked by a real user decision.`;
+
+const FAST_MODE_PROMPT = `## Fast Mode
+
+You are in Fast mode. Work directly.
+
+- Use read, grep, find, ls, bash, edit, and write as needed.
+- Do not use todo, question, or end_conversation; The system disables those tools in Fast mode.
+- Keep the response and edits proportional to the request.`;
+
+const SPRINT_PLAN_MODE_PROMPT = `## Sprint Plan Mode
+
+You are in Sprint Plan mode. The current sprint phase instructions are provided in the conversation, not in this system prompt.
+
+- Work only on the current sprint phase.
+- Use read, grep, find, and ls to inspect the project.
+- Do not use bash, edit, or write; The system blocks those tools in this mode.
+- The question tool is unavailable. Make a reasonable judgment and document assumptions in TODO items when needed.
+- Create or update a concrete TODO list with todo before ending the turn.`;
+
+const SPRINT_ACT_MODE_PROMPT = `## Sprint Act Mode
+
+You are in Sprint Act mode. The current sprint phase instructions are provided in the conversation, not in this system prompt.
+
+- Work only on the current sprint phase.
+- Execute the TODO list and update TODO statuses with todo as work progresses.
+- Use read, grep, find, ls, bash, edit, and write as needed.
+- The question tool is unavailable. Make a reasonable judgment when blocked and document important assumptions.
+- When the current phase is complete and verified, call end_phase with a concise summary.`;