@aibyzero/byz 0.1.3 → 0.1.5

package/dist/workflow-switch.js

@@ -0,0 +1,95 @@
+import { parseArgs } from "./runtime/bundle/index.js";
+
+const WORKFLOW_IDS = new Set(["cm", "cm-plugin", "none"]);
+const NON_RUNTIME_COMMANDS = new Set(["auth", "config", "install", "list", "remove", "uninstall", "update"]);
+
+export function getActiveByzOptionIndexes(args, optionName) {
+	const indexes = new Set();
+	const option = `--${optionName}`;
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index];
+		if (arg !== option && !arg.startsWith(`${option}=`)) continue;
+
+		let probeName = `__byz_${optionName}_probe_${index}`;
+		while (args.some((candidate) => candidate === `--${probeName}` || candidate.startsWith(`--${probeName}=`))) {
+			probeName += "_";
+		}
+		const equalsIndex = arg.indexOf("=");
+		const probeArgs = [...args];
+		probeArgs[index] = equalsIndex === -1 ? `--${probeName}` : `--${probeName}${arg.slice(equalsIndex)}`;
+		if (parseArgs(probeArgs).unknownFlags.has(probeName)) indexes.add(index);
+	}
+	return indexes;
+}
+
+export function shouldLoadWorkflow(args) {
+	const parsed = parseArgs(args);
+	if (parsed.help || parsed.version || parsed.export || parsed.listModels !== undefined) return false;
+	return !NON_RUNTIME_COMMANDS.has(args[0]);
+}
+
+export function shouldEnableWorkflowSwitch(args, { stdinIsTTY, stdoutIsTTY }) {
+	if (!stdinIsTTY || !stdoutIsTTY) return false;
+	const parsed = parseArgs(args);
+	return !parsed.print && parsed.mode !== "json" && parsed.mode !== "rpc";
+}
+
+export function createWorkflowSwitchExtension({ initialResources, initialWorkflowId, resolveResources }) {
+	let activeResources = initialResources;
+	let activeWorkflowId = initialWorkflowId;
+
+	return function workflowSwitchExtension(pi) {
+		pi.on("resources_discover", () => ({
+			promptPaths: activeResources.promptPaths,
+			skillPaths: activeResources.skillPaths,
+		}));
+
+		pi.registerCommand("workflow", {
+			description: "Show or switch the active BYZ workflow",
+			handler: async (args, ctx) => {
+				const targetWorkflowId = args.trim();
+				if (!targetWorkflowId) {
+					ctx.ui.notify(`BYZ workflow: ${activeWorkflowId}`, "info");
+					return;
+				}
+				if (!WORKFLOW_IDS.has(targetWorkflowId)) {
+					ctx.ui.notify("Usage: /workflow [cm|cm-plugin|none]", "error");
+					return;
+				}
+				if (!ctx.isIdle()) {
+					ctx.ui.notify("BYZ cannot switch workflows while the agent is running.", "warning");
+					return;
+				}
+				if (targetWorkflowId === activeWorkflowId) {
+					ctx.ui.notify(`BYZ workflow is already ${activeWorkflowId}.`, "info");
+					return;
+				}
+
+				let nextResources;
+				try {
+					nextResources = await resolveResources(targetWorkflowId);
+				} catch (error) {
+					ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+					return;
+				}
+				if (!ctx.isIdle()) {
+					ctx.ui.notify("BYZ cannot switch workflows while the agent is running.", "warning");
+					return;
+				}
+
+				ctx.ui.notify(`Switching BYZ workflow to ${targetWorkflowId}...`, "info");
+				try {
+					await ctx.replaceByzWorkflowResources(nextResources);
+				} catch (error) {
+					ctx.ui.notify(
+						`BYZ workflow switch failed: ${error instanceof Error ? error.message : String(error)}`,
+						"error",
+					);
+					return;
+				}
+				activeResources = nextResources;
+				activeWorkflowId = targetWorkflowId;
+			},
+		});
+	};
+}

package/dist/workflows.js

@@ -2,6 +2,7 @@ import { readdir, readFile, realpath, stat } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadSkillsFromDir } from "./runtime/bundle/index.js";
+import { getActiveByzOptionIndexes } from "./workflow-switch.js";
 
 const lockPath = fileURLToPath(new URL("../workflows.lock.json", import.meta.url));
 const packageDir = dirname(lockPath);
@@ -175,6 +176,7 @@ function printStatus(status) {
 
 export function parseWorkflowOption(args) {
 	const forwardedArgs = [];
+	const activeWorkflowOptions = getActiveByzOptionIndexes(args, "workflow");
 	let selected;
 	for (let index = 0; index < args.length; index++) {
 		const arg = args[index];
@@ -182,14 +184,14 @@ export function parseWorkflowOption(args) {
 			forwardedArgs.push(...args.slice(index));
 			break;
 		}
-		if (arg === "--workflow") {
+		if (arg === "--workflow" && activeWorkflowOptions.has(index)) {
 			if (selected !== undefined) throw new Error("--workflow may only be specified once.");
 			const value = args[++index];
 			if (!value || value.startsWith("-")) throw new Error("--workflow requires cm, cm-plugin, or none.");
 			selected = value;
 			continue;
 		}
-		if (arg.startsWith("--workflow=")) {
+		if (arg.startsWith("--workflow=") && activeWorkflowOptions.has(index)) {
 			if (selected !== undefined) throw new Error("--workflow may only be specified once.");
 			selected = arg.slice("--workflow=".length);
 			continue;
@@ -203,31 +205,38 @@ export function parseWorkflowOption(args) {
 	return { forwardedArgs, workflowId };
 }
 
-export async function prepareWorkflowRuntimeArgs(args, options = {}) {
-	const { forwardedArgs, workflowId } = parseWorkflowOption(args);
-	if (options.load === false || workflowId === "none") {
-		return { args: forwardedArgs, workflowId };
+export async function resolveWorkflowRuntimeResources(workflowId, args = []) {
+	if (workflowId === "none") {
+		return { promptPaths: [], skillPaths: [] };
 	}
 
 	const status = await checkWorkflow(await getWorkflow(workflowId));
-	const terminatorIndex = forwardedArgs.indexOf("--");
-	const optionArgs = forwardedArgs.slice(0, terminatorIndex === -1 ? forwardedArgs.length : terminatorIndex);
+	const terminatorIndex = args.indexOf("--");
+	const optionArgs = args.slice(0, terminatorIndex === -1 ? args.length : terminatorIndex);
 	const noSkills = optionArgs.some((arg) => arg === "--no-skills" || arg === "-ns");
 	const noPrompts = optionArgs.some((arg) => arg === "--no-prompt-templates" || arg === "-np");
-	const workflowArgs = [];
-	if (!noSkills) {
-		workflowArgs.push(...status.skillsPaths.flatMap((skillPath) => ["--skill", resolve(status.root, skillPath)]));
-	}
-	if (!noPrompts) {
-		workflowArgs.push("--prompt-template", resolve(status.root, status.promptsPath));
+	return {
+		promptPaths: noPrompts ? [] : [resolve(status.root, status.promptsPath)],
+		skillPaths: noSkills ? [] : status.skillsPaths.map((skillPath) => resolve(status.root, skillPath)),
+	};
+}
+
+export async function prepareWorkflowRuntimeArgs(args, options = {}) {
+	const { forwardedArgs, workflowId } = parseWorkflowOption(args);
+	if (options.load === false) {
+		return { args: forwardedArgs, workflowId };
 	}
+
+	const resources = await resolveWorkflowRuntimeResources(workflowId, forwardedArgs);
+	const workflowArgs = resources.skillPaths.flatMap((skillPath) => ["--skill", skillPath]);
+	workflowArgs.push(...resources.promptPaths.flatMap((promptPath) => ["--prompt-template", promptPath]));
 	return {
 		workflowId,
 		args: [...workflowArgs, ...forwardedArgs],
 	};
 }
 
-export async function handleWorkflowCommand(args) {
+export async function handleWorkflowCommand(args, options = {}) {
 	if (args[0] !== "workflow") return false;
 
 	try {
@@ -241,8 +250,14 @@ export async function handleWorkflowCommand(args) {
 		}
 
 		if (command === "status") {
+			const activeWorkflowId = options.workflowId ?? parseWorkflowOption([]).workflowId;
+			const targetWorkflowId = args[2] ?? activeWorkflowId;
+			if (targetWorkflowId === "none") {
+				console.log(`none: ${activeWorkflowId === "none" ? "active" : "available"}`);
+				return true;
+			}
 			await assertDistinctRoots();
-			printStatus(await getWorkflowStatus(await getWorkflow(args[2])));
+			printStatus(await getWorkflowStatus(await getWorkflow(targetWorkflowId)));
 			return true;
 		}
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aibyzero/byz",
-	"version": "0.1.3",
+	"version": "0.1.5",
 	"description": "Business-first coding agent built on Pi",
 	"type": "module",
 	"piConfig": {