pi-thread-engine 0.4.5 → 0.4.7

package/PLAN.md

@@ -1,33 +1,53 @@
-# pi-thread-engine
-
-## Current State (v0.4.4)
-
-### Working
-- All 7 thread types: Base (via /pthread), P (parallel), C (chained), B (branch/meta), F (fusion), Z (zero-touch), L (long)
-- Stories: multi-phase orchestration with planned phase execution
-- Dashboard v3: 3-column grouping (Needs Input | Working | Done), progress bars, output snippets, search, inline reply, `/agents` alias
-- `/threads export [id|--all]` — export to Markdown
-- `E` key in dashboard — quick export
-- Keyboard shortcut: `ctrl+shift+t` opens dashboard
-- Session persistence: survives compaction and `/fork`
-- 3 LLM tools: `thread_spawn`, `thread_status`, `thread_kill`
-- IndyDevDan framework branding: README + THREADS.md
-
-## Next Steps (ranked by impact/effort)
-
-### P0 — Required for completeness
-1. **Live progress with % + ETA** — Wire event emitter from executor to dashboard for real-time progress
-2. **Token/cost counters** — Hook into pi's usage tracking per thread (use `pi.exec` output parsing)
-
-### P1 — High value, low risk
-3. **pi.dev gallery listing** — Already has `pi-package` keyword. Add `pi.video` or `pi.image` to package.json for preview. Ensure repository URL is correct.
-4. **@IndyDevDan outreach** — Draft DM/message saying pi-thread-engine implements his framework
-
-### P2 — Nice to have
-5. **Pinning** — `P` key to pin threads to top
-6. **Git worktree support** — `--worktree` flag on spawn for isolated branches
-7. **pi-memory integration** — Auto-recall from `~/.pi-memory/` before spawning
-
-### P3 — Long term
-8. **ACP support** — Agent Client Protocol interoperability
-9. **Session sharing** — Export/import threads via URL
+# Plan: Git Worktree Threads for pi-thread-engine
+
+## Why
+Orca and pi-builder both have worktree support. pi-thread-engine doesn't. Worktrees give each thread its own isolated branch + working directory, so parallel agents never conflict.
+
+## What We're Building
+A new `/wthread` command that creates a git worktree, runs a thread inside it, and tracks divergence from main.
+
+## Files to Change
+
+### New: `src/core/worktree.ts` (~60 lines)
+- `createWorktree(repoPath, threadId)` → creates worktree + branch
+- `removeWorktree(threadId)` → removes worktree + deletes branch
+- `listWorktrees()` → returns worktree info (branch, path, ahead/behind, dirty)
+- Uses `git worktree` CLI commands (no Rust dependency)
+
+### Modify: `extensions/index.ts` (+80 lines)
+- Add `/wthread "task"` — spawn thread in a worktree
+- Add `/wthread list` — show worktrees with divergence
+- Register as ThreadType "worktree" in registry
+- Wire cleanup on thread completion/kill
+
+### Modify: `src/core/registry.ts` (+5 lines)
+- Add "worktree" as accepted ThreadType
+
+### Modify: `src/core/types.ts` (+5 lines)
+- Add "worktree" to ExecutionBackend or ThreadType
+
+## API
+```
+/wthread "refactor auth"           → create worktree, run task, report results
+/wthread "fix parser" -b fix/parse → use custom branch name
+/wthread list                       → show all active worktrees
+```
+
+## Worktree Lifecycle
+1. `git worktree add -b pi-thread/t-001 <path>` — create
+2. Thread runs in worktree directory using `pi -p "task"` (native backend)
+3. On completion: results captured, divergence tracked
+4. On cleanup: `git worktree remove <path>`, `git branch -D <branch>`
+5. Worktrees stored under `<repo>/.git/worktrees-pi/`
+
+## Test Strategy
+1. Run `/wthread "echo hello"` in a git repo
+2. Verify worktree appears (`git worktree list`)
+3. Run thread, verify results captured
+4. Remove worktree, verify cleanup
+5. Test with non-git repo (graceful error)
+
+## Risks
+- Windows path handling in git worktree (tested: works)
+- Cleanup on pi crash (worktrees persist, need manual cleanup)
+- Branch name collisions (use unique names with thread ID)

package/extensions/index.ts

@@ -18,8 +18,9 @@ import { ThreadRegistry, formatElapsed } from "../src/core/registry.js";
 import { ThreadExecutor } from "../src/core/executor.js";
 import { createDashboard } from "../src/dashboard.js";
 import type { Thread, ThreadType, Story, StoryPhase } from "../src/core/types.js";
-import { writeFileSync } from "fs";
-import { join } from "path";
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from "fs";
+import { join, resolve } from "path";
+import { createWorktree, removeWorktree, listWorktrees, pushWorktreeChanges, cleanupAll, isGitRepo, branchName, findRepoRoot } from "../src/core/worktree.js";
 
 // ── Export helper ───────────────────────────────────────────
 function exportThread(id: string, r: ThreadRegistry, cwd: string): string | null {
@@ -468,6 +469,227 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	// ── /wthread — worktree isolation (port from Grok CLI) ────
+
+	pi.registerCommand("wthread", {
+		description: 'W-Thread: run task in isolated git worktree. Usage: /wthread "task" or /wthread list or /wthread cleanup',
+		handler: async (args, ctx) => {
+			if (!args?.trim()) {
+				ctx.ui.notify('Usage: /wthread "task" | /wthread list | /wthread cleanup', "error");
+				return;
+			}
+
+			// Subcommands
+			const parts = args.trim().split(/\s+/);
+			const sub = parts[0].toLowerCase();
+
+			if (sub === "list") {
+				if (!isGitRepo(ctx.cwd)) { ctx.ui.notify("Not in a git repo", "error"); return; }
+				const wts = listWorktrees(ctx.cwd);
+				if (wts.length === 0) { ctx.ui.notify("No active worktrees", "info"); return; }
+				const lines = wts.map((w) =>
+					`  ${w.threadId} → ${w.branch} @ ${w.path} ${w.dirty ? "⚠ dirty" : ""} (↑${w.ahead} ↓${w.behind})`
+				);
+				ctx.ui.notify(`Worktrees (${wts.length}):\n${lines.join("\n")}`, "info");
+				return;
+			}
+
+			if (sub === "cleanup") {
+				if (!isGitRepo(ctx.cwd)) { ctx.ui.notify("Not in a git repo", "error"); return; }
+				const result = cleanupAll(ctx.cwd);
+				ctx.ui.notify(`Cleaned: ${result.removed} worktrees (${result.failed} failed)`, result.failed > 0 ? "warning" : "info");
+				return;
+			}
+
+			if (sub === "push" && parts.length >= 2) {
+				const threadId = parts[1];
+				const msg = parts.slice(2).join(" ") || undefined;
+				const ok = pushWorktreeChanges(ctx.cwd, threadId, msg);
+				ctx.ui.notify(ok ? `Pushed ${threadId} changes` : "Push failed", ok ? "info" : "error");
+				return;
+			}
+
+			// Default: create worktree and run task
+			if (!isGitRepo(ctx.cwd)) { ctx.ui.notify("Not in a git repo — can't create worktree", "error"); return; }
+
+			const task = args.trim();
+			const thread = registry.create("worktree", `W: ${task.slice(0, 40)}`, [task], {
+				cwd: ctx.cwd,
+				backend: "native",
+			});
+
+			ctx.ui.notify(`🌳 W-Thread ${thread.id}: Creating worktree for "${task.slice(0, 50)}"...`, "info");
+
+			executor.dispatch(thread).then(() => {
+				if (thread.state === "completed") {
+					ctx.ui.notify(`✅ W-Thread ${thread.id} done in worktree! Use /wthread push ${thread.id} to merge.`, "info");
+				} else {
+					ctx.ui.notify(`❌ W-Thread ${thread.id} ${thread.state}`, "error");
+				}
+			});
+		},
+	});
+
+	// ── /plan — Plan mode (port from Grok CLI) ────────────────
+
+	let planFile: string | null = null;
+	let planApproved = false;
+
+	pi.registerCommand("plan", {
+		description: 'Plan mode: write, review, and approve a plan before execution. Usage: /plan "goal" | /plan approve | /plan reject | /plan status',
+		handler: async (args, ctx) => {
+			if (!args?.trim()) {
+				ctx.ui.notify("Usage: /plan <goal> | /plan approve | /plan reject | /plan status", "error");
+				return;
+			}
+
+			const sub = args.trim().toLowerCase();
+
+			if (sub === "approve") {
+				if (!planFile) { ctx.ui.notify("No active plan. Use /plan \"goal\" first.", "error"); return; }
+				planApproved = true;
+				ctx.ui.notify("✅ Plan approved! You can now execute the planned work.", "info");
+				return;
+			}
+
+			if (sub === "reject") {
+				planFile = null;
+				planApproved = false;
+				ctx.ui.notify("✗ Plan rejected. Revise and re-submit with /plan \"goal\".", "warning");
+				return;
+			}
+
+			if (sub === "status") {
+				if (planFile && existsSync(planFile)) {
+					const content = readFileSync(planFile, "utf8");
+					const status = planApproved ? "✅ Approved" : "⏳ Awaiting approval";
+					ctx.ui.notify(`Plan status: ${status}\n\n${content.slice(0, 1000)}`, "info");
+				} else {
+					ctx.ui.notify("No active plan.", "info");
+				}
+				return;
+			}
+
+			// Create a new plan
+			const goal = args.trim();
+			planApproved = false;
+
+			// Create plan directory
+			const planDir = join(ctx.cwd, ".pi", "plans");
+			if (!existsSync(planDir)) mkdirSync(planDir, { recursive: true });
+			const ts = new Date().toISOString().slice(0, 19).replace(/[T:]/g, "-");
+			planFile = join(planDir, `plan-${ts}.md`);
+
+			const planMd = [
+				`# Plan: ${goal}`,
+				"",
+				"## Goal",
+				goal,
+				"",
+				"## Approach",
+				"(Generated by agent — review and edit before approving)",
+				"",
+				"## Steps",
+				"1. ",
+				"2. ",
+				"3. ",
+				"",
+				"## Verification",
+				"- ",
+				"",
+				"---",
+				`Created: ${new Date().toISOString()}`,
+				"Status: draft (run `/plan approve` to approve, `/plan reject` to reject)",
+			].join("\n");
+
+			writeFileSync(planFile, planMd, "utf8");
+			ctx.ui.notify(
+				`📋 Plan created at ${planFile}\nReview it, then run /plan approve or /plan reject.`,
+				"info"
+			);
+		},
+	});
+
+	// ── /loop — Scheduled recurring tasks (port from Grok CLI) ─
+
+	const scheduler = new Map<string, { interval: number; prompt: string; timer: ReturnType<typeof setInterval> | null }>();
+
+	function parseInterval(input: string): number | null {
+		const m = input.match(/^(\d+)(s|m|h|d)$/);
+		if (!m) return null;
+		const n = parseInt(m[1]);
+		switch (m[2]) {
+			case "s": return n * 1000;
+			case "m": return n * 60 * 1000;
+			case "h": return n * 3600 * 1000;
+			case "d": return n * 86400 * 1000;
+			default: return null;
+		}
+	}
+
+	pi.registerCommand("loop", {
+		description: 'Schedule a recurring task. Usage: /loop 5m "check test status" | /loop list | /loop stop <id>',
+		handler: async (args, ctx) => {
+			if (!args?.trim()) {
+				ctx.ui.notify("Usage: /loop <interval> <prompt> | /loop list | /loop stop <id>", "error");
+				return;
+			}
+
+			const parts = args.trim().split(/\s+/);
+			const sub = parts[0].toLowerCase();
+
+			if (sub === "list") {
+				if (scheduler.size === 0) { ctx.ui.notify("No scheduled tasks.", "info"); return; }
+				const lines: string[] = [];
+				for (const [id, task] of scheduler) {
+					const intervalStr = `${task.interval / 1000}s`;
+					lines.push(`  ${id}: every ${intervalStr} — "${task.prompt.slice(0, 50)}"`);
+				}
+				ctx.ui.notify(`Scheduled tasks (${scheduler.size}):\n${lines.join("\n")}`, "info");
+				return;
+			}
+
+			if (sub === "stop" && parts.length >= 2) {
+				const id = parts[1];
+				const task = scheduler.get(id);
+				if (!task) { ctx.ui.notify(`No scheduled task with id ${id}`, "error"); return; }
+				if (task.timer) clearInterval(task.timer);
+				scheduler.delete(id);
+				ctx.ui.notify(`Stopped ${id}`, "info");
+				return;
+			}
+
+			// Parse: /loop 5m "prompt"
+			const intervalStr = parts[0];
+			const interval = parseInterval(intervalStr);
+			if (!interval) { ctx.ui.notify(`Invalid interval: ${intervalStr}. Use format: 30s, 5m, 2h, 1d`, "error"); return; }
+
+			const prompt = parts.slice(1).join(" ");
+			if (!prompt) { ctx.ui.notify("No prompt specified", "error"); return; }
+
+			const id = `loop-${Date.now()}`;
+			ctx.ui.notify(`⏰ /loop ${id}: every ${intervalStr} — "${prompt.slice(0, 50)}"`, "info");
+
+			// Fire immediately
+			const thread = registry.create("scheduled", `Loop: ${prompt.slice(0, 40)}`, [prompt], {
+				cwd: ctx.cwd,
+				backend: "native",
+			});
+			executor.dispatch(thread);
+
+			// Schedule recurring
+			const timer = setInterval(() => {
+				const t = registry.create("scheduled", `Loop: ${prompt.slice(0, 40)}`, [prompt], {
+					cwd: ctx.cwd,
+					backend: "native",
+				});
+				executor.dispatch(t);
+			}, interval);
+
+			scheduler.set(id, { interval, prompt, timer });
+		},
+	});
+
 	// ── /story — STORIES (the unique layer) ──────────────────────
 
 	pi.registerCommand("story", {
@@ -569,9 +791,12 @@ export default function (pi: ExtensionAPI) {
 			"- fusion: same prompt to N agents/models, compare results (native, UNIQUE)",
 			"- zero: autonomous + verification command gate (native, UNIQUE)",
 			"- long: extended autonomous run (native)",
+			"- worktree: run in isolated git worktree (native, port from Grok CLI)",
+			"- plan: structured plan→approve→execute gate (native, port from Grok CLI)",
+			"- scheduled: recurring scheduled task (native, port from Grok CLI)",
 		].join("\n"),
 		parameters: Type.Object({
-			type: StringEnum(["parallel", "fusion", "chained", "meta", "long", "zero"] as const),
+			type: StringEnum(["parallel", "fusion", "chained", "meta", "long", "zero", "worktree", "plan", "scheduled"] as const),
 			prompts: Type.Array(Type.String(), { description: "Task prompts" }),
 			models: Type.Optional(Type.Array(Type.String(), { description: "Models for fusion (e.g. ['anthropic/claude-sonnet-4', 'google/gemini-2.5-pro'])" })),
 			count: Type.Optional(Type.Number({ description: "Agent count for fusion (default 3)" })),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-thread-engine",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Thread-Based Engineering for pi — all 7 thread types + stories + fusion + zero-touch + TUI dashboard. Based on @IndyDevDan framework from agenticengineer.com.",
   "type": "module",
   "license": "MIT",