oh-pi 0.1.61 → 0.1.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-pi",
-  "version": "0.1.61",
+  "version": "0.1.63",
   "description": "One-click setup for pi-coding-agent. Like oh-my-zsh for pi.",
   "type": "module",
   "bin": {

package/pi-package/extensions/ant-colony/index.ts

@@ -14,7 +14,8 @@ import { join } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Text, Container, Spacer, matchesKey } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { runColony, type QueenCallbacks } from "./queen.js";
+import { runColony, resumeColony, type QueenCallbacks } from "./queen.js";
+import { Nest } from "./nest.js";
 import type { ColonyState, ColonyMetrics, AntStreamEvent } from "./types.js";
 
 // ═══ Helpers ═══
@@ -174,7 +175,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
     modelOverrides: Record<string, string>;
     cwd: string;
     modelRegistry?: any;
-  }) {
+  }, resume = false) {
     if (activeColony) {
       pi.events.emit("ant-colony:notify", { msg: "A colony is already running. Use /colony-stop first.", level: "warning" });
       return;
@@ -236,7 +237,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       appendFileSync(gitignorePath, `${gitContent.length && !gitContent.endsWith("\n") ? "\n" : ""}.ant-colony/\n`);
     }
 
-    colony.promise = runColony({
+    const colonyOpts = {
       cwd: params.cwd,
       goal: params.goal,
       maxAnts: params.maxAnts,
@@ -247,7 +248,8 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       callbacks,
       authStorage: undefined,
       modelRegistry: params.modelRegistry,
-    });
+    };
+    colony.promise = resume ? resumeColony(colonyOpts) : runColony(colonyOpts);
 
     activeColony = colony;
     throttledRender();
@@ -569,6 +571,30 @@ export default function antColonyExtension(pi: ExtensionAPI) {
     },
   });
 
+  pi.registerCommand("colony-resume", {
+    description: "Resume a colony from its last checkpoint",
+    async handler(_args, ctx) {
+      if (activeColony) {
+        ctx.ui.notify("A colony is already running.", "warning");
+        return;
+      }
+      const found = Nest.findResumable(ctx.cwd);
+      if (!found) {
+        ctx.ui.notify("No resumable colony found.", "info");
+        return;
+      }
+      ctx.ui.notify(`🐜 Resuming colony: ${found.state.goal.slice(0, 60)}...`, "info");
+      launchBackgroundColony({
+        cwd: ctx.cwd,
+        goal: found.state.goal,
+        maxCost: found.state.maxCost ?? undefined,
+        currentModel: ctx.currentModel,
+        modelOverrides: {},
+        modelRegistry: ctx.modelRegistry,
+      }, true);
+    },
+  });
+
   // ═══ Cleanup on shutdown ═══
   pi.on("session_shutdown", async () => {
     if (activeColony) {

package/pi-package/extensions/ant-colony/nest.ts

@@ -263,4 +263,33 @@ export class Nest {
   private readJson<T>(file: string): T {
     return JSON.parse(fs.readFileSync(file, "utf-8")) as T;
   }
+
+  /** 查找可恢复的蚁群（状态为 working/scouting/reviewing 且未完成） */
+  static findResumable(cwd: string): { colonyId: string; state: ColonyState } | null {
+    const parentDir = path.join(cwd, ".ant-colony");
+    try {
+      for (const dir of fs.readdirSync(parentDir)) {
+        const stateFile = path.join(parentDir, dir, "state.json");
+        if (!fs.existsSync(stateFile)) continue;
+        const state = JSON.parse(fs.readFileSync(stateFile, "utf-8")) as ColonyState;
+        if (!state.finishedAt && state.status !== "done" && state.status !== "failed" && state.status !== "budget_exceeded") {
+          return { colonyId: dir, state };
+        }
+      }
+    } catch { /* no .ant-colony dir */ }
+    return null;
+  }
+
+  /** 从已有文件恢复，不调用 init */
+  restore(): void {
+    this.stateCache = this.readJson<ColonyState>(this.stateFile);
+    // 将 claimed/active 任务重置为 pending（蚂蚁已死）
+    for (const task of this.getAllTasks()) {
+      if (task.status === "claimed" || task.status === "active") {
+        task.status = "pending";
+        task.claimedBy = undefined;
+        this.writeTask(task);
+      }
+    }
+  }
 }

package/pi-package/extensions/ant-colony/queen.ts

@@ -463,6 +463,37 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
       }
     }
 
+    // ═══ 持续探索：Worker 完成后检查是否有新发现，有则再派 Scout ═══
+    const discoveries = nest.getAllPheromones().filter(p => p.type === "discovery");
+    const allDone = nest.getAllTasks().filter(t => t.status === "done");
+    if (discoveries.length > allDone.length && nest.getState().maxCost != null) {
+      const spent = nest.getState().ants.reduce((s, a) => s + a.usage.cost, 0);
+      if (spent < (nest.getState().maxCost ?? Infinity)) {
+        callbacks.onPhase?.("scouting", "Re-exploring based on new discoveries...");
+        emitSignal("scouting", "Re-exploring...");
+        await runAntWave({ ...waveBase, caste: "scout" });
+
+        const newTasks = nest.getAllTasks().filter(t =>
+          (t.caste === "worker" || t.caste === "drone") && t.status === "pending"
+        );
+        if (newTasks.length > 0) {
+          const drones = newTasks.filter(t => t.caste === "drone");
+          if (drones.length > 0) await runAntWave({ ...waveBase, caste: "drone" });
+
+          callbacks.onPhase?.("working", `${newTasks.length} new tasks from re-exploration`);
+          emitSignal("working", `${newTasks.length} new tasks`);
+          const result = await runAntWave({ ...waveBase, caste: "worker" });
+          if (result === "budget") {
+            nest.updateState({ status: "budget_exceeded", finishedAt: Date.now() });
+            emitSignal("budget_exceeded", "Budget exhausted");
+            const budgetState = nest.getState();
+            callbacks.onComplete?.(budgetState);
+            return budgetState;
+          }
+        }
+      }
+    }
+
     // ═══ Auto-check: run tsc before soldier review ═══
     let tscPassed = true;
     try {
@@ -511,3 +542,76 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
     cleanup();
   }
 }
+
+/**
+ * 从检查点恢复蚁群 — 跳过已完成的阶段，继续执行未完成的任务
+ */
+export async function resumeColony(opts: QueenOptions): Promise<ColonyState> {
+  const found = Nest.findResumable(opts.cwd);
+  if (!found) return runColony(opts); // 无可恢复状态，正常启动
+
+  const nest = new Nest(opts.cwd, found.colonyId);
+  nest.restore();
+
+  const { signal, callbacks } = opts;
+  const waveBase: Omit<WaveOptions, "caste"> = {
+    nest, cwd: opts.cwd, signal, callbacks,
+    currentModel: opts.currentModel,
+    modelOverrides: opts.modelOverrides,
+    authStorage: opts.authStorage,
+    modelRegistry: opts.modelRegistry,
+  };
+
+  const emitSignal = (phase: ColonyState["status"], message: string) => {
+    const m = nest.getState().metrics;
+    const active = nest.getState().ants.filter(a => a.status === "working").length;
+    const progress = m.tasksTotal > 0 ? m.tasksDone / m.tasksTotal : 0;
+    callbacks.onSignal?.({ phase, progress, active, cost: m.totalCost, message });
+  };
+
+  const cleanup = () => {
+    nest.destroy();
+    const parentDir = path.join(opts.cwd, ".ant-colony");
+    try {
+      const entries = fs.readdirSync(parentDir);
+      if (entries.length === 0) fs.rmdirSync(parentDir);
+    } catch { /* ignore */ }
+  };
+
+  callbacks.onPhase?.("working", "Resuming colony from checkpoint...");
+  emitSignal("working", "Resuming...");
+
+  try {
+    // 执行所有 pending 任务
+    const pendingDrones = nest.getAllTasks().filter(t => t.caste === "drone" && t.status === "pending");
+    if (pendingDrones.length > 0) await runAntWave({ ...waveBase, caste: "drone" });
+
+    const pendingWorkers = nest.getAllTasks().filter(t => t.caste === "worker" && t.status === "pending");
+    if (pendingWorkers.length > 0) {
+      const result = await runAntWave({ ...waveBase, caste: "worker" });
+      if (result === "budget") {
+        nest.updateState({ status: "budget_exceeded", finishedAt: Date.now() });
+        emitSignal("budget_exceeded", "Budget exhausted");
+        const s = nest.getState();
+        callbacks.onComplete?.(s);
+        return s;
+      }
+    }
+
+    const finalMetrics = updateMetrics(nest);
+    nest.updateState({ status: "done", finishedAt: Date.now(), metrics: finalMetrics });
+    const finalState = nest.getState();
+    callbacks.onComplete?.(finalState);
+    emitSignal("done", `Resumed: ${finalMetrics.tasksDone}/${finalMetrics.tasksTotal} tasks done`);
+    return finalState;
+
+  } catch (e) {
+    nest.updateState({ status: "failed", finishedAt: Date.now() });
+    const failState = nest.getState();
+    callbacks.onComplete?.(failState);
+    emitSignal("failed", String(e).slice(0, 100));
+    return failState;
+  } finally {
+    cleanup();
+  }
+}