@valni/cli-darwin-x64 0.1.2 → 0.1.4

package/runtime/examples/extensions/event-bus.ts

@@ -1,7 +1,7 @@
 /**
  * Inter-extension event bus example.
  *
- * Shows pi.events for communication between extensions. One extension
+ * Shows valni.events for communication between extensions. One extension
  * can emit events that other extensions listen to.
  *
  * Usage: /emit [event-name] [data] - emit an event on the bus
@@ -9,33 +9,33 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	// Store ctx for use in event handler
 	let currentCtx: ExtensionContext | undefined;
 
-	pi.on("session_start", async (_event, ctx) => {
+	valni.on("session_start", async (_event, ctx) => {
 		currentCtx = ctx;
 	});
 
 	// Listen for events from other extensions
-	pi.events.on("my:notification", (data) => {
+	valni.events.on("my:notification", (data) => {
 		const { message, from } = data as { message: string; from: string };
 		currentCtx?.ui.notify(`Event from ${from}: ${message}`, "info");
 	});
 
 	// Command to emit events (emits "my:notification" which the listener above receives)
-	pi.registerCommand("emit", {
+	valni.registerCommand("emit", {
 		description: "Emit my:notification event (usage: /emit message)",
 		handler: async (args, _ctx) => {
 			const message = args.trim() || "hello";
-			pi.events.emit("my:notification", { message, from: "/emit command" });
+			valni.events.emit("my:notification", { message, from: "/emit command" });
 			// Listener above will show the notification
 		},
 	});
 
 	// Example: emit on session start
-	pi.on("session_start", async () => {
-		pi.events.emit("my:notification", {
+	valni.on("session_start", async () => {
+		valni.events.emit("my:notification", {
 			message: "Session started",
 			from: "event-bus-example",
 		});

package/runtime/examples/extensions/file-trigger.ts

@@ -11,15 +11,15 @@
 import * as fs from "node:fs";
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
-	pi.on("session_start", async (_event, ctx) => {
+export default function (valni: ExtensionAPI) {
+	valni.on("session_start", async (_event, ctx) => {
 		const triggerFile = "/tmp/agent-trigger.txt";
 
 		fs.watch(triggerFile, () => {
 			try {
 				const content = fs.readFileSync(triggerFile, "utf-8").trim();
 				if (content) {
-					pi.sendMessage(
+					valni.sendMessage(
 						{
 							customType: "file-trigger",
 							content: `External trigger: ${content}`,

package/runtime/examples/extensions/git-checkpoint.ts

@@ -7,26 +7,26 @@
 
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	const checkpoints = new Map<string, string>();
 	let currentEntryId: string | undefined;
 
 	// Track the current entry ID when user messages are saved
-	pi.on("tool_result", async (_event, ctx) => {
+	valni.on("tool_result", async (_event, ctx) => {
 		const leaf = ctx.sessionManager.getLeafEntry();
 		if (leaf) currentEntryId = leaf.id;
 	});
 
-	pi.on("turn_start", async () => {
+	valni.on("turn_start", async () => {
 		// Create a git stash entry before LLM makes changes
-		const { stdout } = await pi.exec("git", ["stash", "create"]);
+		const { stdout } = await valni.exec("git", ["stash", "create"]);
 		const ref = stdout.trim();
 		if (ref && currentEntryId) {
 			checkpoints.set(currentEntryId, ref);
 		}
 	});
 
-	pi.on("session_before_fork", async (event, ctx) => {
+	valni.on("session_before_fork", async (event, ctx) => {
 		const ref = checkpoints.get(event.entryId);
 		if (!ref) return;
 
@@ -41,12 +41,12 @@ export default function (pi: ExtensionAPI) {
 		]);
 
 		if (choice?.startsWith("Yes")) {
-			await pi.exec("git", ["stash", "apply", ref]);
+			await valni.exec("git", ["stash", "apply", ref]);
 			ctx.ui.notify("Code restored to checkpoint", "info");
 		}
 	});
 
-	pi.on("agent_end", async () => {
+	valni.on("agent_end", async () => {
 		// Clear checkpoints after agent completes
 		checkpoints.clear();
 	});

package/runtime/examples/extensions/git-merge-and-resolve.ts

@@ -8,8 +8,8 @@
  * with file, line range, and ours/theirs sections so it can resolve them.
  * Also re-sends unresolved conflicts from a previous incomplete merge.
  *
- * Start pi with this extension:
- *   pi -e ./examples/extensions/git-merge-and-resolve.ts
+ * Start valni with this extension:
+ *   valni -e ./examples/extensions/git-merge-and-resolve.ts
  */
 import { createReadStream } from "node:fs";
 import { join } from "node:path";
@@ -24,8 +24,8 @@ interface ConflictBlock {
 }
 
 /** Parse conflict markers from working tree files with unmerged paths. */
-async function findConflicts(pi: ExtensionAPI, cwd: string): Promise<ConflictBlock[]> {
-	const { stdout, code } = await pi.exec("git", ["diff", "--name-only", "--diff-filter=U"]);
+async function findConflicts(valni: ExtensionAPI, cwd: string): Promise<ConflictBlock[]> {
+	const { stdout, code } = await valni.exec("git", ["diff", "--name-only", "--diff-filter=U"]);
 	if (code !== 0 || !stdout.trim()) return [];
 
 	const blocks: ConflictBlock[] = [];
@@ -70,21 +70,21 @@ function formatConflicts(ref: string, blocks: ConflictBlock[]): string {
 	return lines.join("\n");
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.on("agent_end", async (_event, ctx) => {
-		const { code: revParseCode } = await pi.exec("git", ["rev-parse", "--git-dir"]);
+export default function (valni: ExtensionAPI) {
+	valni.on("agent_end", async (_event, ctx) => {
+		const { code: revParseCode } = await valni.exec("git", ["rev-parse", "--git-dir"]);
 		if (revParseCode !== 0) return;
 
 		let ref = "MERGE_HEAD";
 
 		// If not already in a merge, attempt one
-		const { code: mergeHeadCode } = await pi.exec("git", ["rev-parse", "MERGE_HEAD"]);
+		const { code: mergeHeadCode } = await valni.exec("git", ["rev-parse", "MERGE_HEAD"]);
 		if (mergeHeadCode !== 0) {
 			// Only attempt a new merge if the working tree is clean
-			const { stdout: status } = await pi.exec("git", ["status", "--porcelain"]);
+			const { stdout: status } = await valni.exec("git", ["status", "--porcelain"]);
 			if (status.trim()) return;
 
-			const { stdout: upstream, code: upstreamCode } = await pi.exec("git", [
+			const { stdout: upstream, code: upstreamCode } = await valni.exec("git", [
 				"rev-parse",
 				"--abbrev-ref",
 				"--symbolic-full-name",
@@ -96,20 +96,20 @@ export default function (pi: ExtensionAPI) {
 			const remote = ref.split("/")[0];
 			ctx.ui.notify(`git-merge-and-resolve: fetching ${remote}, merging ${ref}`, "info");
 
-			const { code: fetchCode, stderr: fetchErr } = await pi.exec("git", ["fetch", remote]);
+			const { code: fetchCode, stderr: fetchErr } = await valni.exec("git", ["fetch", remote]);
 			if (fetchCode !== 0) {
 				ctx.ui.notify(`git-merge-and-resolve: fetch failed: ${fetchErr.trim()}`, "warning");
 				return;
 			}
 
-			const { code: mergeCode } = await pi.exec("git", ["merge", "--no-ff", ref]);
+			const { code: mergeCode } = await valni.exec("git", ["merge", "--no-ff", ref]);
 			if (mergeCode === 0) return;
 		}
 
 		// Either we just merged with conflicts, or we were already in an unfinished merge
-		const conflicts = await findConflicts(pi, ctx.cwd);
+		const conflicts = await findConflicts(valni, ctx.cwd);
 		if (conflicts.length === 0) return;
 
-		pi.sendUserMessage(formatConflicts(ref, conflicts), { deliverAs: "followUp" });
+		valni.sendUserMessage(formatConflicts(ref, conflicts), { deliverAs: "followUp" });
 	});
 }

package/runtime/examples/extensions/github-issue-autocomplete.ts

@@ -39,8 +39,8 @@ function parseGitHubRepo(remoteUrl: string): string | undefined {
 	return undefined;
 }
 
-async function resolveGitHubRepo(pi: ExtensionAPI, cwd: string): Promise<RepoResolution> {
-	const result = await pi.exec("git", ["remote", "-v"], { cwd, timeout: 5_000 });
+async function resolveGitHubRepo(valni: ExtensionAPI, cwd: string): Promise<RepoResolution> {
+	const result = await valni.exec("git", ["remote", "-v"], { cwd, timeout: 5_000 });
 	if (result.code !== 0) {
 		return { ok: false, error: "github-issue-autocomplete: cwd is not a git repository" };
 	}
@@ -127,9 +127,9 @@ function createIssueAutocompleteProvider(
 	};
 }
 
-export default function (pi: ExtensionAPI): void {
-	pi.on("session_start", async (_event, ctx) => {
-		const resolvedRepo = await resolveGitHubRepo(pi, ctx.cwd);
+export default function (valni: ExtensionAPI): void {
+	valni.on("session_start", async (_event, ctx) => {
+		const resolvedRepo = await resolveGitHubRepo(valni, ctx.cwd);
 		if (!resolvedRepo.ok) {
 			ctx.ui.notify(resolvedRepo.error, "error");
 			return;
@@ -141,7 +141,7 @@ export default function (pi: ExtensionAPI): void {
 
 		const getIssues = async (): Promise<GitHubIssue[] | undefined> => {
 			issuesPromise ||= (async () => {
-				const result = await pi.exec(
+				const result = await valni.exec(
 					"gh",
 					[
 						"issue",

package/runtime/examples/extensions/hello.ts

@@ -21,6 +21,6 @@ const helloTool = defineTool({
 	},
 });
 
-export default function (pi: ExtensionAPI) {
-	pi.registerTool(helloTool);
+export default function (valni: ExtensionAPI) {
+	valni.registerTool(helloTool);
 }

package/runtime/examples/extensions/hidden-thinking-label.ts

@@ -5,7 +5,7 @@
  * when thinking blocks are hidden.
  *
  * Usage:
- *   pi --extension examples/extensions/hidden-thinking-label.ts
+ *   valni --extension examples/extensions/hidden-thinking-label.ts
  *
  * Test:
  *   1. Load this extension
@@ -22,18 +22,18 @@ import type { ExtensionAPI, ExtensionContext } from "@valni/cli";
 
 const DEFAULT_LABEL = "Pondering...";
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	let label = DEFAULT_LABEL;
 
 	const applyLabel = (ctx: ExtensionContext) => {
 		ctx.ui.setHiddenThinkingLabel(label);
 	};
 
-	pi.on("session_start", async (_event, ctx) => {
+	valni.on("session_start", async (_event, ctx) => {
 		applyLabel(ctx);
 	});
 
-	pi.registerCommand("thinking-label", {
+	valni.registerCommand("thinking-label", {
 		description: "Set the hidden thinking label. Use without args to reset.",
 		handler: async (args, ctx) => {
 			const nextLabel = args.trim();

package/runtime/examples/extensions/inline-bash.ts

@@ -1,8 +1,8 @@
 /**
  * Inline Bash Extension - expands inline bash commands in user prompts.
  *
- * Start pi with this extension:
- *   pi -e ./examples/extensions/inline-bash.ts
+ * Start valni with this extension:
+ *   valni -e ./examples/extensions/inline-bash.ts
  *
  * Then type prompts with inline bash:
  *   What's in !{pwd}?
@@ -16,11 +16,11 @@
  */
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	const PATTERN = /!\{([^}]+)\}/g;
 	const TIMEOUT_MS = 30000;
 
-	pi.on("input", async (event, ctx) => {
+	valni.on("input", async (event, ctx) => {
 		const text = event.text;
 
 		// Don't process if it's a whole-line bash command (starts with !)
@@ -51,7 +51,7 @@ export default function (pi: ExtensionAPI) {
 		// Execute each command and collect results
 		for (const { full, command } of matches) {
 			try {
-				const bashResult = await pi.exec("bash", ["-c", command], {
+				const bashResult = await valni.exec("bash", ["-c", command], {
 					timeout: TIMEOUT_MS,
 				});
 

package/runtime/examples/extensions/input-transform-streaming.ts

@@ -8,15 +8,15 @@
  * file changes, giving the model immediate context. During steering the
  * exec call is skipped so the correction reaches the model without delay.
  *
- * Start pi with this extension:
- *   pi -e ./examples/extensions/input-transform-streaming.ts
+ * Start valni with this extension:
+ *   valni -e ./examples/extensions/input-transform-streaming.ts
  */
 import type { ExtensionAPI } from "@valni/cli";
 
 const TRIGGER = /\b(changes?|diff|modified)\b/i;
 
-export default function (pi: ExtensionAPI) {
-	pi.on("input", async (event) => {
+export default function (valni: ExtensionAPI) {
+	valni.on("input", async (event) => {
 		// During steering, skip the exec call — corrections should be fast
 		if (event.streamingBehavior === "steer") {
 			return { action: "continue" };
@@ -26,7 +26,7 @@ export default function (pi: ExtensionAPI) {
 			return { action: "continue" };
 		}
 
-		const { stdout, code } = await pi.exec("git", ["diff", "--stat"]);
+		const { stdout, code } = await valni.exec("git", ["diff", "--stat"]);
 		if (code !== 0 || !stdout.trim()) {
 			return { action: "continue" };
 		}

package/runtime/examples/extensions/input-transform.ts

@@ -1,18 +1,18 @@
 /**
  * Input Transform Example - demonstrates the `input` event for intercepting user input.
  *
- * Start pi with this extension:
- *   pi -e ./examples/extensions/input-transform.ts
+ * Start valni with this extension:
+ *   valni -e ./examples/extensions/input-transform.ts
  *
- * Then type these inside pi:
+ * Then type these inside valni:
  *   ?quick What is TypeScript?  → "Respond briefly: What is TypeScript?"
  *   ping                        → "pong" (instant, no LLM)
  *   time                        → current time (instant, no LLM)
  */
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
-	pi.on("input", async (event, ctx) => {
+export default function (valni: ExtensionAPI) {
+	valni.on("input", async (event, ctx) => {
 		// Source-based logic: skip processing for extension-injected messages
 		if (event.source === "extension") {
 			return { action: "continue" };

package/runtime/examples/extensions/interactive-shell.ts

@@ -5,7 +5,7 @@
  * with full terminal access. The TUI suspends while they run.
  *
  * Usage:
- *   pi -e examples/extensions/interactive-shell.ts
+ *   valni -e examples/extensions/interactive-shell.ts
  *
  *   !vim file.txt        # Auto-detected as interactive
  *   !i any-command       # Force interactive mode with !i prefix
@@ -128,8 +128,8 @@ function isInteractiveCommand(command: string): boolean {
 	return false;
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.on("user_bash", async (event, ctx) => {
+export default function (valni: ExtensionAPI) {
+	valni.on("user_bash", async (event, ctx) => {
 		let command = event.command;
 		let forceInteractive = false;
 

package/runtime/examples/extensions/mac-system-theme.ts

@@ -1,8 +1,8 @@
 /**
- * Syncs pi theme with macOS system appearance (dark/light mode).
+ * Syncs valni theme with macOS system appearance (dark/light mode).
  *
  * Usage:
- *   pi -e examples/extensions/mac-system-theme.ts
+ *   valni -e examples/extensions/mac-system-theme.ts
  */
 
 import { exec } from "node:child_process";
@@ -22,10 +22,10 @@ async function isDarkMode(): Promise<boolean> {
 	}
 }
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	let intervalId: ReturnType<typeof setInterval> | null = null;
 
-	pi.on("session_start", async (_event, ctx) => {
+	valni.on("session_start", async (_event, ctx) => {
 		let currentTheme = (await isDarkMode()) ? "dark" : "light";
 		ctx.ui.setTheme(currentTheme);
 
@@ -38,7 +38,7 @@ export default function (pi: ExtensionAPI) {
 		}, 2000);
 	});
 
-	pi.on("session_shutdown", () => {
+	valni.on("session_shutdown", () => {
 		if (intervalId) {
 			clearInterval(intervalId);
 			intervalId = null;

package/runtime/examples/extensions/message-renderer.ts

@@ -10,9 +10,9 @@
 import type { ExtensionAPI } from "@valni/cli";
 import { Box, Text } from "@valni/tui";
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	// Register custom renderer for "status-update" messages
-	pi.registerMessageRenderer("status-update", (message, { expanded }, theme) => {
+	valni.registerMessageRenderer("status-update", (message, { expanded }, theme) => {
 		const details = message.details as { level: string; timestamp: number } | undefined;
 		const level = details?.level ?? "info";
 
@@ -35,7 +35,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// Command to send status messages
-	pi.registerCommand("status", {
+	valni.registerCommand("status", {
 		description: "Send a status message (usage: /status [warn|error] message)",
 		handler: async (args, _ctx) => {
 			const parts = args.trim().split(/\s+/);
@@ -48,7 +48,7 @@ export default function (pi: ExtensionAPI) {
 				content = parts.slice(1).join(" ") || "Status update";
 			}
 
-			pi.sendMessage({
+			valni.sendMessage({
 				customType: "status-update",
 				content,
 				display: true,

package/runtime/examples/extensions/minimal-mode.ts

@@ -11,7 +11,7 @@
  * - Minimal: Shows only tool call, no output (this extension's collapsed mode)
  *
  * Usage:
- *   pi -e ./minimal-mode.ts
+ *   valni -e ./minimal-mode.ts
  *
  * Then use ctrl+o to toggle between minimal (collapsed) and full (expanded) views.
  */
@@ -64,11 +64,11 @@ function getBuiltInTools(cwd: string) {
 	return tools;
 }
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	// =========================================================================
 	// Read Tool
 	// =========================================================================
-	pi.registerTool({
+	valni.registerTool({
 		name: "read",
 		label: "read",
 		description:
@@ -115,7 +115,7 @@ export default function (pi: ExtensionAPI) {
 	// =========================================================================
 	// Bash Tool
 	// =========================================================================
-	pi.registerTool({
+	valni.registerTool({
 		name: "bash",
 		label: "bash",
 		description:
@@ -164,7 +164,7 @@ export default function (pi: ExtensionAPI) {
 	// =========================================================================
 	// Write Tool
 	// =========================================================================
-	pi.registerTool({
+	valni.registerTool({
 		name: "write",
 		label: "write",
 		description:
@@ -206,7 +206,7 @@ export default function (pi: ExtensionAPI) {
 	// =========================================================================
 	// Edit Tool
 	// =========================================================================
-	pi.registerTool({
+	valni.registerTool({
 		name: "edit",
 		label: "edit",
 		description:
@@ -251,7 +251,7 @@ export default function (pi: ExtensionAPI) {
 	// =========================================================================
 	// Find Tool
 	// =========================================================================
-	pi.registerTool({
+	valni.registerTool({
 		name: "find",
 		label: "find",
 		description:
@@ -309,7 +309,7 @@ export default function (pi: ExtensionAPI) {
 	// =========================================================================
 	// Grep Tool
 	// =========================================================================
-	pi.registerTool({
+	valni.registerTool({
 		name: "grep",
 		label: "grep",
 		description:
@@ -371,7 +371,7 @@ export default function (pi: ExtensionAPI) {
 	// =========================================================================
 	// Ls Tool
 	// =========================================================================
-	pi.registerTool({
+	valni.registerTool({
 		name: "ls",
 		label: "ls",
 		description:

package/runtime/examples/extensions/modal-editor.ts

@@ -1,7 +1,7 @@
 /**
  * Modal Editor - vim-like modal editing example
  *
- * Usage: pi --extension ./examples/extensions/modal-editor.ts
+ * Usage: valni --extension ./examples/extensions/modal-editor.ts
  *
  * - Escape: insert → normal mode (in normal mode, aborts agent)
  * - i: normal → insert mode
@@ -78,8 +78,8 @@ class ModalEditor extends CustomEditor {
 	}
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.on("session_start", (_event, ctx) => {
+export default function (valni: ExtensionAPI) {
+	valni.on("session_start", (_event, ctx) => {
 		ctx.ui.setEditorComponent((tui, theme, kb) => new ModalEditor(tui, theme, kb));
 	});
 }

package/runtime/examples/extensions/model-status.ts

@@ -4,13 +4,13 @@
  * Demonstrates the `model_select` hook which fires when the model changes
  * via /model command, Ctrl+P cycling, or session restore.
  *
- * Usage: pi -e ./model-status.ts
+ * Usage: valni -e ./model-status.ts
  */
 
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
-	pi.on("model_select", async (event, ctx) => {
+export default function (valni: ExtensionAPI) {
+	valni.on("model_select", async (event, ctx) => {
 		const { model, previousModel, source } = event;
 
 		// Format model identifiers

package/runtime/examples/extensions/notify.ts

@@ -1,7 +1,7 @@
 /**
- * Pi Notify Extension
+ * Valni Notify Extension
  *
- * Sends a native terminal notification when Pi agent is done and waiting for input.
+ * Sends a native terminal notification when Valni agent is done and waiting for input.
  * Supports multiple terminal protocols:
  * - OSC 777: Ghostty, iTerm2, WezTerm, rxvt-unicode
  * - OSC 99: Kitty
@@ -48,8 +48,8 @@ function notify(title: string, body: string): void {
 	}
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.on("agent_end", async () => {
-		notify("Pi", "Ready for input");
+export default function (valni: ExtensionAPI) {
+	valni.on("agent_end", async () => {
+		notify("Valni", "Ready for input");
 	});
 }