pi-taskflow 0.0.12 → 0.0.14

package/extensions/index.ts

@@ -10,13 +10,19 @@
  * host conversation context — only the final phase output is returned.
  */
 
-import * as fs from "node:fs";
-import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { StringEnum } from "@earendil-works/pi-ai";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
+import {
+	RECOMMENDED_DEFAULTS,
+	readSettings,
+	writeSettings,
+	formatRolesReport,
+	formatDiffReport,
+	formatFlowResult,
+	runInteractiveInit,
+} from "./init.ts";
 import { Type } from "typebox";
 import { type AgentScope, discoverAgents, readSubagentSettings } from "./agents.ts";
 import { renderRunResult, summarizeRun } from "./render.ts";
@@ -33,6 +39,7 @@ import {
 	saveFlow,
 	saveRun,
 } from "./store.ts";
+import { CacheStore } from "./cache.ts";
 
 interface TaskflowDetails {
 	state?: RunState;
@@ -53,8 +60,8 @@ const ShorthandStep = Type.Object(
 );
 
 const TaskflowParams = Type.Object({
-	action: StringEnum(["run", "save", "resume", "list", "agents", "init"] as const, {
-		description: "What to do: run a flow, save a definition, resume a paused run, list saved flows, list available agents, or init model role configuration",
+	action: StringEnum(["run", "save", "resume", "list", "agents", "init", "verify", "cache-clear"] as const, {
+		description: "What to do: run a flow, save a definition, resume a paused run, list saved flows, list available agents, init model role configuration, or clear the cross-run memoization cache",
 		default: "run",
 	}),
 	name: Type.Optional(Type.String({ description: "Name of a saved flow (for run/save without inline define)" })),
@@ -87,6 +94,19 @@ const TaskflowParams = Type.Object({
 	scope: Type.Optional(
 		StringEnum(["user", "project"] as const, { description: "Where to save (action=save)", default: "project" }),
 	),
+	mode: Type.Optional(
+		StringEnum(["show", "apply-defaults", "interactive"] as const, {
+			description:
+				"Init action mode. 'show' is read-only (default); 'apply-defaults' requires force:true; 'interactive' requires a UI session.",
+			default: "show",
+		}),
+	),
+	force: Type.Optional(
+		Type.Boolean({
+			description:
+				"Destructive: overwrites modelRoles in settings.json. Required for mode='apply-defaults'.",
+		}),
+	),
 });
 
 function makeRunState(def: Taskflow, args: Record<string, unknown>, cwd: string): RunState {
@@ -258,7 +278,7 @@ export default function (pi: ExtensionAPI) {
 			"For simple non-DAG delegations (like the subagent tool) skip the DSL: pass `task` (+optional `agent`) for one task, `tasks:[{task,agent?}]` to run in parallel, or `chain:[{task,agent?}]` to run sequentially (reference the prior step with {previous.output}).",
 			"Use action=save to persist a definition as a reusable /tf:<name> command. action=resume continues a paused run. action=list shows saved flows. Use action=agents to list available agents — do NOT invent agent names; either use an agent from that list or omit the 'agent' field to auto-select the default agent.",
 			"DSL: {name, args?, concurrency?, budget?:{maxUSD,maxTokens}, phases:[{id, type, agent, task, dependsOn?, join?:'all'|'any', when?, retry?:{max,backoffMs,factor}, over?(map), as?(map), branches?(parallel), from?(reduce), use?(flow), with?(flow), output?:'json', final?}]}.",
-			"Phase types: agent (one subagent), parallel (static branches), map (dynamic fan-out over an array), gate (VERDICT: PASS/BLOCK quality gate), reduce (aggregate from N phases), approval (human-in-the-loop pause), flow (run a saved sub-flow). join:'any' is an OR-join; when is a conditional guard; retry adds backoff; budget caps run cost.",
+			"Phase types: agent (one subagent), parallel (static branches), map (dynamic fan-out over an array), gate (VERDICT: PASS/BLOCK quality gate), reduce (aggregate from N phases), approval (human-in-the-loop pause), flow (run a saved sub-flow), loop (re-run a task until 'until' is truthy / converged / maxIterations; body reads {loop.iteration} and {loop.lastOutput}), tournament (spawn N variants of 'task' — or distinct 'branches' — then a judge picks the best / aggregates; mode:'best'|'aggregate'). join:'any' is an OR-join; when is a conditional guard; retry adds backoff; budget caps run cost.",
 			"Interpolation: {args.X}, {steps.ID.output}, {steps.ID.json}, {item} (map), {previous.output}.",
 		].join(" "),
 		parameters: TaskflowParams,
@@ -273,52 +293,81 @@ export default function (pi: ExtensionAPI) {
 			const action = params.action ?? "run";
 
 			// init — configure model roles
-	if (action === "init") {
-		const settingsPath = path.join(getAgentDir(), "settings.json");
-		let existing: Record<string, unknown> = {};
-		try { existing = JSON.parse(fs.readFileSync(settingsPath, "utf-8")); } catch {}
-
-		const roleDescs: Record<string, string> = {
-			fast: "cheap & quick (executor, scout, recover, verifier, doc-writer, test-engineer)",
-			strong: "balanced (planner, reviewer, executor-code)",
-			thinker: "deep analysis (analyst, critic)",
-			arbiter: "final judgment (plan-arbiter, final-arbiter)",
-			vision: "multimodal (executor-ui, visual-explorer)",
-			reasoner: "cautious reasoning (risk-reviewer, security-reviewer)",
-		};
-
-		if (existing.modelRoles) {
-			const roles = existing.modelRoles as Record<string, string>;
-			const text = [
-				`Model roles already configured in ${settingsPath}:`,
-				...Object.entries(roles).map(([k, v]) => `  ${k.padEnd(10)} → ${v}  (${roleDescs[k] ?? ""})`),
-				``,
-				`To reconfigure, run /tf init interactively or edit settings.json directly.`,
-			].join("\n");
-			return { content: [{ type: "text", text }], details: { action } satisfies TaskflowDetails };
-		}
+			if (action === "init") {
+				let settings: Record<string, unknown>;
+				try {
+					settings = readSettings();
+				} catch (e) {
+					return errorResult(
+						action,
+						`Failed to read settings.json: ${e instanceof Error ? e.message : String(e)}. ` +
+							`Fix the file or remove it.`,
+					);
+				}
+				const current = (settings.modelRoles ?? {}) as Record<string, string>;
+				const mode = params.mode;
+
+				// v0.0.13 deprecation bridge: mode omitted → old behavior
+				if (mode === undefined) {
+					if (Object.keys(current).length === 0) {
+						// v0.0.12 compat: auto-write recommended defaults when modelRoles is empty
+						console.warn(
+							"[taskflow] action=init with no mode is deprecated and will require explicit mode in v0.0.14. " +
+								"Use mode='apply-defaults' with force=true.",
+						);
+						writeSettings({ ...settings, modelRoles: { ...RECOMMENDED_DEFAULTS } });
+						const text = formatDiffReport({}, RECOMMENDED_DEFAULTS);
+						return { content: [{ type: "text", text }], details: { action } satisfies TaskflowDetails };
+					}
+					// mode omitted + modelRoles exist → show
+					const text = formatRolesReport(current);
+					return { content: [{ type: "text", text }], details: { action } satisfies TaskflowDetails };
+				}
 
-		const defaults: Record<string, string> = {
-			fast: "openrouter/deepseek/deepseek-v4-flash",
-			strong: "openrouter/xiaomi/mimo-v2.5-pro",
-			thinker: "openrouter/deepseek/deepseek-v4-pro",
-			arbiter: "openrouter/qwen/qwen3.7-max",
-			vision: "minimax/MiniMax-M3",
-			reasoner: "z-ai/glm-5.1",
-		};
-
-		const newSettings = { ...existing, modelRoles: defaults };
-		fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-		fs.writeFileSync(settingsPath, JSON.stringify(newSettings, null, 2) + "\n", "utf-8");
-
-		const text = [
-			`Wrote default model roles to ${settingsPath}:`,
-			...Object.entries(defaults).map(([k, v]) => `  ${k.padEnd(10)} → ${v}  (${roleDescs[k]})`),
-			``,
-			`These models require provider-specific API keys. Edit settings.json or run /tf init interactively.`,
-		].join("\n");
-		return { content: [{ type: "text", text }], details: { action } satisfies TaskflowDetails };
-	}
+				// mode === "show" (read-only, never overwrites)
+				if (mode === "show") {
+					const text = formatRolesReport(current);
+					return { content: [{ type: "text", text }], details: { action } satisfies TaskflowDetails };
+				}
+
+				// mode === "apply-defaults" requires explicit force=true
+				if (mode === "apply-defaults") {
+					if (!params.force)
+						return errorResult(action, "mode=apply-defaults requires force=true to overwrite.");
+					const merged: Record<string, string> = { ...RECOMMENDED_DEFAULTS };
+					for (const key of Object.keys(current)) {
+						if (!(key in merged)) merged[key] = current[key]; // stale-preserved
+					}
+					writeSettings({ ...settings, modelRoles: merged });
+					const text = formatDiffReport(current, merged);
+					return { content: [{ type: "text", text }], details: { action } satisfies TaskflowDetails };
+				}
+
+				// mode === "interactive" — requires a UI session
+				if (mode === "interactive") {
+					if (!ctx.hasUI)
+						return errorResult(action, "mode=interactive requires an interactive session.");
+					const enabledModels = (settings.enabledModels as string[] | undefined) ?? [];
+					const modelList =
+						enabledModels.length > 0
+							? enabledModels
+									.map((id) => ctx.modelRegistry.find(id.split("/")[0], id.split("/").slice(1).join("/")))
+									.filter((m): m is NonNullable<typeof m> => m !== undefined)
+							: ctx.modelRegistry.getAvailable();
+					const result = await runInteractiveInit({
+						hasUI: ctx.hasUI,
+						signal: signal ?? new AbortController().signal,
+						ui: ctx.ui as ExtensionUIContext,
+						modelRegistry: ctx.modelRegistry,
+						modelList,
+						currentRoles: current,
+					});
+					const text = formatFlowResult(result);
+					return { content: [{ type: "text", text }], details: { action } satisfies TaskflowDetails };
+				}
+
+				return errorResult(action, `Unknown init mode: ${String(mode)}`);
+			}
 
 	// agents — list available agents the LLM can use in phase definitions
 			if (action === "agents") {
@@ -345,6 +394,61 @@ export default function (pi: ExtensionAPI) {
 				return { content: [{ type: "text", text }], details: { action } satisfies TaskflowDetails };
 			}
 
+			if (action === "verify") {
+				const { verifyTaskflow } = await import("./verify.ts");
+				// Load definition: inline define takes priority, then saved name
+				let def: Taskflow | undefined;
+				if (params.define) {
+					const d = params.define as Record<string, unknown>;
+					if (typeof d === "object" && d !== null && Array.isArray(d.phases)) {
+						def = d as unknown as Taskflow;
+					} else if (isShorthand(params.define)) {
+						const r = validateTaskflow(params.define);
+						if (r.ok) def = params.define as unknown as Taskflow;
+					}
+				} else if (params.name) {
+					const saved = getFlow(ctx.cwd, params.name);
+					if (saved) def = saved.def;
+				}
+				if (!def) {
+					return errorResult(action, "Provide 'define' (DSL) or 'name' (saved flow) to verify.");
+				}
+				// Schema validation first
+				const vr = validateTaskflow(def, { cwd: ctx.cwd ? String(ctx.cwd) : undefined });
+				if (!vr.ok) {
+					return errorResult(action, `Schema validation failed:\n${vr.errors.join("\n")}`);
+				}
+				const result = verifyTaskflow({ name: def.name!, phases: def.phases!, budget: def.budget, concurrency: def.concurrency });
+				const lines: string[] = [];
+				lines.push(`# Verification of "${def.name}"`);
+				lines.push("");
+				if (result.issues.length === 0) {
+					lines.push("✅ No issues found.");
+				} else {
+					const errors = result.issues.filter((i) => i.severity === "error");
+					const warnings = result.issues.filter((i) => i.severity === "warning");
+					if (errors.length) {
+						lines.push(`## Errors (${errors.length})`);
+						for (const e of errors) lines.push(`- **${e.category}**${e.phaseId ? ` [${e.phaseId}]` : ""}: ${e.message}`);
+					}
+					if (warnings.length) {
+						lines.push(`## Warnings (${warnings.length})`);
+						for (const w of warnings) lines.push(`- ${w.category}${w.phaseId ? ` [${w.phaseId}]` : ""}: ${w.message}`);
+					}
+					lines.push("");
+					lines.push(result.ok ? "Status: PASS (no errors)" : "Status: FAIL (errors found)");
+				}
+				return { content: [{ type: "text", text: lines.join("\n") }], details: { action } satisfies TaskflowDetails };
+			}
+
+			if (action === "cache-clear") {
+				const removed = new CacheStore(ctx.cwd).clear();
+				return {
+					content: [{ type: "text", text: `Cleared ${removed} cross-run cache entr${removed === 1 ? "y" : "ies"}.` }],
+					details: { action } satisfies TaskflowDetails,
+				};
+			}
+
 			// resume
 			if (action === "resume") {
 				if (!params.runId)
@@ -559,85 +663,57 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			if (sub === "init") {
-				const settingsPath = path.join(getAgentDir(), "settings.json");
-				let existing: Record<string, unknown> = {};
-				try { existing = JSON.parse(fs.readFileSync(settingsPath, "utf-8")); } catch {}
-				const currentRoles = (existing.modelRoles ?? {}) as Record<string, string>;
-
-				// Role definitions: name → { description, recommended models }
-				// Role definitions: name → description (no per-role filtering)
-				const roleDefs: Array<{ role: string; desc: string }> = [
-					{ role: "fast",     desc: "Cheap & quick — high-volume, low-stakes tasks (executor, scout, recover, verifier, doc-writer, test-engineer)" },
-					{ role: "strong",   desc: "Balanced — planning, review, moderate complexity (planner, reviewer, executor-code)" },
-					{ role: "thinker",  desc: "Deep analysis — requirements, ambiguity detection, critique (analyst, critic)" },
-					{ role: "arbiter",  desc: "Final judgment — tiebreak, plan quality gates (plan-arbiter, final-arbiter)" },
-					{ role: "vision",   desc: "Multimodal — UI work, design reading, Figma analysis (executor-ui, visual-explorer)" },
-					{ role: "reasoner", desc: "Cautious reasoning — security, risk review, sensitive changes (risk-reviewer, security-reviewer)" },
-				];
+				let settings: Record<string, unknown>;
+				try {
+					settings = readSettings();
+				} catch (e) {
+					ctx.ui.notify(
+						`Failed to read settings.json: ${e instanceof Error ? e.message : String(e)}`,
+						"error",
+					);
+					return;
+				}
+				const currentRoles = (settings.modelRoles ?? {}) as Record<string, string>;
 
 				if (!ctx.hasUI) {
 					if (Object.keys(currentRoles).length > 0) {
 						ctx.ui.notify(
-							`Current model roles:\n` +
-							Object.entries(currentRoles).map(([k, v]) => `  ${k.padEnd(10)} → ${v}`).join("\n"),
-						"info"
+							formatRolesReport(currentRoles),
+							"info",
 						);
 					} else {
 						ctx.ui.notify(
-							`No modelRoles configured. Run /tf init in an interactive session to select models.`,
-						"warning"
+							"No modelRoles configured. Run /tf init in an interactive session to select models.",
+							"warning",
 						);
 					}
 					return;
 				}
 
-				// Use the user's scoped/enabled models (same list as /model command).
-				// Fall back to all auth-configured models if none are scoped.
-				const enabledModels = (existing.enabledModels as string[] | undefined) ?? [];
-				const modelList = enabledModels.length > 0
-					? enabledModels
-					: ctx.modelRegistry.getAvailable().map(m => `${m.provider}/${m.id}`);
-
-				// Interactive: walk through each role using the same model list
-				const chosen: Record<string, string> = {};
-				for (const rd of roleDefs) {
-					const current = currentRoles[rd.role];
-
-					const seen = new Set<string>();
-					const options: string[] = [];
-					for (const m of modelList) {
-						if (seen.has(m)) continue;
-						seen.add(m);
-						options.push(m === current ? `${m} (current)` : m);
-					}
-					options.push("───────────────");
-					options.push("Custom (type your own)");
-
-					const title = `Model for '${rd.role}' — ${rd.desc}` + (current ? `\nCurrent: ${current}` : "");
-					const pick = await ctx.ui.select(title, options, { signal: ctx.signal });
-
-					if (!pick || pick.startsWith("───")) {
-						chosen[rd.role] = current ?? modelList[0] ?? "";
-						continue;
-					}
-
-					if (pick === "Custom (type your own)") {
-						const custom = await ctx.ui.input(`Enter model identifier for '${rd.role}'`, "provider/model-id", { signal: ctx.signal });
-						chosen[rd.role] = custom?.trim() || current || "";
-					} else {
-						chosen[rd.role] = pick.replace(" (current)", "");
-					}
-				}
-
-				// Save
-				const newSettings = { ...existing, modelRoles: chosen };
-				fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-				fs.writeFileSync(settingsPath, JSON.stringify(newSettings, null, 2) + "\n", "utf-8");
-
+				const enabledModels = (settings.enabledModels as string[] | undefined) ?? [];
+				const modelList =
+					enabledModels.length > 0
+						? enabledModels
+								.map((id) => ctx.modelRegistry.find(id.split("/")[0], id.split("/").slice(1).join("/")))
+								.filter((m): m is NonNullable<typeof m> => m !== undefined)
+						: ctx.modelRegistry.getAvailable();
+				const result = await runInteractiveInit({
+					hasUI: ctx.hasUI,
+					signal: ctx.signal ?? new AbortController().signal,
+					ui: ctx.ui,
+					modelRegistry: ctx.modelRegistry,
+					modelList,
+					currentRoles,
+				});
 				ctx.ui.notify(
-					`Saved model roles to ${settingsPath}:\n` +
-					Object.entries(chosen).map(([k, v]) => `  ${k.padEnd(10)} → ${v}`).join("\n"),
-				"info"
+					result.kind === "saved"
+						? `Saved model roles to ${result.savedPath}:\n${Object.entries(result.chosen)
+								.map(([k, v]) => `  ${k.padEnd(10)} → ${v}`)
+								.join("\n")}`
+						: result.kind === "no-change"
+							? "No changes made."
+							: "Init cancelled.",
+					result.kind === "saved" ? "info" : "info",
 				);
 				return;
 			}