threadwell 0.0.0 → 0.0.1

package/examples/extensions/border-status-editor.ts

@@ -0,0 +1,147 @@
+import type { Component, EditorTheme, TUI } from "@threadwell/tui";
+import { truncateToWidth, visibleWidth } from "@threadwell/tui";
+import { CustomEditor, type ExtensionAPI, type ExtensionContext, type KeybindingsManager } from "threadwell";
+
+function fitBorder(
+	left: string,
+	right: string,
+	width: number,
+	border: (text: string) => string,
+	fill: (text: string) => string = border,
+): string {
+	if (width <= 0) return "";
+	if (width === 1) return border("─");
+
+	let leftText = left;
+	let rightText = right;
+	const fixedWidth = 2;
+	const minimumGap = 3;
+
+	while (
+		fixedWidth + visibleWidth(leftText) + visibleWidth(rightText) + minimumGap > width &&
+		visibleWidth(rightText) > 0
+	) {
+		rightText = truncateToWidth(rightText, Math.max(0, visibleWidth(rightText) - 1), "");
+	}
+	while (
+		fixedWidth + visibleWidth(leftText) + visibleWidth(rightText) + minimumGap > width &&
+		visibleWidth(leftText) > 0
+	) {
+		leftText = truncateToWidth(leftText, Math.max(0, visibleWidth(leftText) - 1), "");
+	}
+
+	const gapWidth = Math.max(0, width - fixedWidth - visibleWidth(leftText) - visibleWidth(rightText));
+	return `${border("─")}${leftText}${fill("─".repeat(gapWidth))}${rightText}${border("─")}`;
+}
+
+function formatCwd(cwd: string): string {
+	const home = process.env.HOME;
+	if (home && cwd.startsWith(home)) {
+		return `~${cwd.slice(home.length)}`;
+	}
+	return cwd;
+}
+
+function formatContext(ctx: ExtensionContext): string {
+	const usage = ctx.getContextUsage();
+	const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow;
+	if (!contextWindow || !usage || usage.percent === null) {
+		return "ctx ?";
+	}
+	return `ctx ${Math.round(usage.percent)}%/${(contextWindow / 1000).toFixed(0)}k`;
+}
+
+function formatThinking(level: string): string {
+	return level === "off" ? "off" : level;
+}
+
+class EmptyFooter implements Component {
+	render(): string[] {
+		return [];
+	}
+
+	invalidate(): void {}
+}
+
+export default function (threadwell: ExtensionAPI) {
+	let isWorking = false;
+	let spinnerIndex = 0;
+	let spinnerTimer: ReturnType<typeof setInterval> | undefined;
+	let activeTui: TUI | undefined;
+	const spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+	const stopSpinner = () => {
+		if (spinnerTimer) {
+			clearInterval(spinnerTimer);
+			spinnerTimer = undefined;
+		}
+	};
+
+	threadwell.on("agent_start", () => {
+		isWorking = true;
+		stopSpinner();
+		spinnerTimer = setInterval(() => {
+			spinnerIndex = (spinnerIndex + 1) % spinnerFrames.length;
+			activeTui?.requestRender();
+		}, 80);
+		activeTui?.requestRender();
+	});
+
+	threadwell.on("agent_end", () => {
+		isWorking = false;
+		stopSpinner();
+		activeTui?.requestRender();
+	});
+
+	threadwell.on("session_shutdown", () => {
+		stopSpinner();
+		activeTui = undefined;
+	});
+
+	threadwell.on("session_start", (_event, ctx) => {
+		ctx.ui.setWorkingVisible(false);
+		ctx.ui.setFooter(() => new EmptyFooter());
+
+		let branch: string | undefined;
+
+		const refreshBranch = async () => {
+			const result = await threadwell
+				.exec("git", ["branch", "--show-current"], { cwd: ctx.cwd })
+				.catch(() => undefined);
+			const stdout = result?.stdout.trim();
+			branch = stdout && stdout.length > 0 ? stdout : undefined;
+			activeTui?.requestRender();
+		};
+		void refreshBranch();
+
+		class BorderStatusEditor extends CustomEditor {
+			constructor(tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) {
+				super(tui, theme, keybindings, { paddingX: 0 });
+				activeTui = tui;
+			}
+
+			render(width: number): string[] {
+				const lines = super.render(width);
+				if (lines.length < 2) return lines;
+
+				const thm = ctx.ui.theme;
+				const model = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "no model";
+				const thinking = threadwell.getThinkingLevel();
+				const topLeft = isWorking ? thm.fg("accent", ` ${spinnerFrames[spinnerIndex]} `) : "";
+				const topRight = "";
+				const bottomLeft = thm.fg("muted", ` ${model} · ${formatThinking(thinking)} `);
+				const bottomRight = thm.fg(
+					"muted",
+					` ${formatContext(ctx)} · ${formatCwd(ctx.cwd)}${branch ? ` (${branch})` : ""} `,
+				);
+				const borderColor = (text: string) => this.borderColor(text);
+
+				lines[0] = fitBorder(topLeft, topRight, width, borderColor);
+				lines[lines.length - 1] = fitBorder(bottomLeft, bottomRight, width, borderColor);
+				return lines;
+			}
+		}
+
+		ctx.ui.setEditorComponent((tui, theme, keybindings) => new BorderStatusEditor(tui, theme, keybindings));
+	});
+}

package/examples/extensions/built-in-tool-renderer.ts

@@ -0,0 +1,249 @@
+/**
+ * Built-in Tool Renderer Example - Custom rendering for built-in tools
+ *
+ * Demonstrates how to override the rendering of built-in tools (read, bash,
+ * edit, write) without changing their behavior. Each tool is re-registered
+ * with the same name, delegating execution to the original implementation
+ * while providing compact custom renderCall/renderResult functions.
+ *
+ * This is useful for users who prefer more concise tool output, or who want
+ * to highlight specific information (e.g., showing only the diff stats for
+ * edit, or just the exit code for bash).
+ *
+ * How it works:
+ * - registerTool() with the same name as a built-in replaces it entirely
+ * - We create instances of the original tools via createReadTool(), etc.
+ *   and delegate execute() to them
+ * - renderCall() controls what's shown when the tool is invoked
+ * - renderResult() controls what's shown after execution completes
+ * - renderShell: "self" lets a tool render its own outer shell instead of
+ *   using the default boxed shell from ToolExecutionComponent
+ * - The `expanded` flag in renderResult indicates whether the user has
+ *   toggled the tool output open (via ctrl+e or clicking)
+ *
+ * Usage:
+ *   thread -e ./built-in-tool-renderer.ts
+ */
+
+import { Text } from "@threadwell/tui";
+import type { BashToolDetails, EditToolDetails, ExtensionAPI, ReadToolDetails } from "threadwell";
+import { createBashTool, createEditTool, createReadTool, createWriteTool } from "threadwell";
+
+export default function (threadwell: ExtensionAPI) {
+	const cwd = process.cwd();
+
+	// --- Read tool: show path and line count ---
+	const originalRead = createReadTool(cwd);
+	threadwell.registerTool({
+		name: "read",
+		label: "read",
+		description: originalRead.description,
+		parameters: originalRead.parameters,
+
+		async execute(toolCallId, params, signal, onUpdate) {
+			return originalRead.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme, _context) {
+			let text = theme.fg("toolTitle", theme.bold("read "));
+			text += theme.fg("accent", args.path);
+			if (args.offset || args.limit) {
+				const parts: string[] = [];
+				if (args.offset) parts.push(`offset=${args.offset}`);
+				if (args.limit) parts.push(`limit=${args.limit}`);
+				text += theme.fg("dim", ` (${parts.join(", ")})`);
+			}
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { expanded, isPartial }, theme, _context) {
+			if (isPartial) return new Text(theme.fg("warning", "Reading..."), 0, 0);
+
+			const details = result.details as ReadToolDetails | undefined;
+			const content = result.content[0];
+
+			if (content?.type === "image") {
+				return new Text(theme.fg("success", "Image loaded"), 0, 0);
+			}
+
+			if (content?.type !== "text") {
+				return new Text(theme.fg("error", "No content"), 0, 0);
+			}
+
+			const lineCount = content.text.split("\n").length;
+			let text = theme.fg("success", `${lineCount} lines`);
+
+			if (details?.truncation?.truncated) {
+				text += theme.fg("warning", ` (truncated from ${details.truncation.totalLines})`);
+			}
+
+			if (expanded) {
+				const lines = content.text.split("\n").slice(0, 15);
+				for (const line of lines) {
+					text += `\n${theme.fg("dim", line)}`;
+				}
+				if (lineCount > 15) {
+					text += `\n${theme.fg("muted", `... ${lineCount - 15} more lines`)}`;
+				}
+			}
+
+			return new Text(text, 0, 0);
+		},
+	});
+
+	// --- Bash tool: show command and exit code ---
+	const originalBash = createBashTool(cwd);
+	threadwell.registerTool({
+		name: "bash",
+		label: "bash",
+		description: originalBash.description,
+		parameters: originalBash.parameters,
+
+		async execute(toolCallId, params, signal, onUpdate) {
+			return originalBash.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme, _context) {
+			let text = theme.fg("toolTitle", theme.bold("$ "));
+			const cmd = args.command.length > 80 ? `${args.command.slice(0, 77)}...` : args.command;
+			text += theme.fg("accent", cmd);
+			if (args.timeout) {
+				text += theme.fg("dim", ` (timeout: ${args.timeout}s)`);
+			}
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { expanded, isPartial }, theme, _context) {
+			if (isPartial) return new Text(theme.fg("warning", "Running..."), 0, 0);
+
+			const details = result.details as BashToolDetails | undefined;
+			const content = result.content[0];
+			const output = content?.type === "text" ? content.text : "";
+
+			const exitMatch = output.match(/exit code: (\d+)/);
+			const exitCode = exitMatch ? parseInt(exitMatch[1], 10) : null;
+			const lineCount = output.split("\n").filter((l) => l.trim()).length;
+
+			let text = "";
+			if (exitCode === 0 || exitCode === null) {
+				text += theme.fg("success", "done");
+			} else {
+				text += theme.fg("error", `exit ${exitCode}`);
+			}
+			text += theme.fg("dim", ` (${lineCount} lines)`);
+
+			if (details?.truncation?.truncated) {
+				text += theme.fg("warning", " [truncated]");
+			}
+
+			if (expanded) {
+				const lines = output.split("\n").slice(0, 20);
+				for (const line of lines) {
+					text += `\n${theme.fg("dim", line)}`;
+				}
+				if (output.split("\n").length > 20) {
+					text += `\n${theme.fg("muted", "... more output")}`;
+				}
+			}
+
+			return new Text(text, 0, 0);
+		},
+	});
+
+	// --- Edit tool: show path and diff stats ---
+	const originalEdit = createEditTool(cwd);
+	threadwell.registerTool({
+		name: "edit",
+		label: "edit",
+		description: originalEdit.description,
+		parameters: originalEdit.parameters,
+		renderShell: "self",
+
+		async execute(toolCallId, params, signal, onUpdate) {
+			return originalEdit.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme, _context) {
+			let text = theme.fg("toolTitle", theme.bold("edit "));
+			text += theme.fg("accent", args.path);
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { expanded, isPartial }, theme, _context) {
+			if (isPartial) return new Text(theme.fg("warning", "Editing..."), 0, 0);
+
+			const details = result.details as EditToolDetails | undefined;
+			const content = result.content[0];
+
+			if (content?.type === "text" && content.text.startsWith("Error")) {
+				return new Text(theme.fg("error", content.text.split("\n")[0]), 0, 0);
+			}
+
+			if (!details?.diff) {
+				return new Text(theme.fg("success", "Applied"), 0, 0);
+			}
+
+			// Count additions and removals from the diff
+			const diffLines = details.diff.split("\n");
+			let additions = 0;
+			let removals = 0;
+			for (const line of diffLines) {
+				if (line.startsWith("+") && !line.startsWith("+++")) additions++;
+				if (line.startsWith("-") && !line.startsWith("---")) removals++;
+			}
+
+			let text = theme.fg("success", `+${additions}`);
+			text += theme.fg("dim", " / ");
+			text += theme.fg("error", `-${removals}`);
+
+			if (expanded) {
+				for (const line of diffLines.slice(0, 30)) {
+					if (line.startsWith("+") && !line.startsWith("+++")) {
+						text += `\n${theme.fg("success", line)}`;
+					} else if (line.startsWith("-") && !line.startsWith("---")) {
+						text += `\n${theme.fg("error", line)}`;
+					} else {
+						text += `\n${theme.fg("dim", line)}`;
+					}
+				}
+				if (diffLines.length > 30) {
+					text += `\n${theme.fg("muted", `... ${diffLines.length - 30} more diff lines`)}`;
+				}
+			}
+
+			return new Text(text, 0, 0);
+		},
+	});
+
+	// --- Write tool: show path and size ---
+	const originalWrite = createWriteTool(cwd);
+	threadwell.registerTool({
+		name: "write",
+		label: "write",
+		description: originalWrite.description,
+		parameters: originalWrite.parameters,
+
+		async execute(toolCallId, params, signal, onUpdate) {
+			return originalWrite.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme, _context) {
+			let text = theme.fg("toolTitle", theme.bold("write "));
+			text += theme.fg("accent", args.path);
+			const lineCount = args.content.split("\n").length;
+			text += theme.fg("dim", ` (${lineCount} lines)`);
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial }, theme, _context) {
+			if (isPartial) return new Text(theme.fg("warning", "Writing..."), 0, 0);
+
+			const content = result.content[0];
+			if (content?.type === "text" && content.text.startsWith("Error")) {
+				return new Text(theme.fg("error", content.text.split("\n")[0]), 0, 0);
+			}
+
+			return new Text(theme.fg("success", "Written"), 0, 0);
+		},
+	});
+}

package/examples/extensions/claude-rules.ts

@@ -0,0 +1,86 @@
+/**
+ * Claude Rules Extension
+ *
+ * Scans the project's .claude/rules/ folder for rule files and lists them
+ * in the system prompt. The agent can then use the read tool to load
+ * specific rules when needed.
+ *
+ * Best practices for .claude/rules/:
+ * - Keep rules focused: Each file should cover one topic (e.g., testing.md, api-design.md)
+ * - Use descriptive filenames: The filename should indicate what the rules cover
+ * - Use conditional rules sparingly: Only add paths frontmatter when rules truly apply to specific file types
+ * - Organize with subdirectories: Group related rules (e.g., frontend/, backend/)
+ *
+ * Usage:
+ * 1. Copy this file to ~/.threadwell/agent/extensions/ or your project's .threadwell/extensions/
+ * 2. Create .claude/rules/ folder in your project root
+ * 3. Add .md files with your rules
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI } from "threadwell";
+
+/**
+ * Recursively find all .md files in a directory
+ */
+function findMarkdownFiles(dir: string, basePath: string = ""): string[] {
+	const results: string[] = [];
+
+	if (!fs.existsSync(dir)) {
+		return results;
+	}
+
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+	for (const entry of entries) {
+		const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+
+		if (entry.isDirectory()) {
+			results.push(...findMarkdownFiles(path.join(dir, entry.name), relativePath));
+		} else if (entry.isFile() && entry.name.endsWith(".md")) {
+			results.push(relativePath);
+		}
+	}
+
+	return results;
+}
+
+export default function claudeRulesExtension(threadwell: ExtensionAPI) {
+	let ruleFiles: string[] = [];
+	let rulesDir: string = "";
+
+	// Scan for rules on session start
+	threadwell.on("session_start", async (_event, ctx) => {
+		rulesDir = path.join(ctx.cwd, ".claude", "rules");
+		ruleFiles = findMarkdownFiles(rulesDir);
+
+		if (ruleFiles.length > 0) {
+			ctx.ui.notify(`Found ${ruleFiles.length} rule(s) in .claude/rules/`, "info");
+		}
+	});
+
+	// Append available rules to system prompt
+	threadwell.on("before_agent_start", async (event) => {
+		if (ruleFiles.length === 0) {
+			return;
+		}
+
+		const rulesList = ruleFiles.map((f) => `- .claude/rules/${f}`).join("\n");
+
+		return {
+			systemPrompt:
+				event.systemPrompt +
+				`
+
+## Project Rules
+
+The following project rules are available in .claude/rules/:
+
+${rulesList}
+
+When working on tasks related to these rules, use the read tool to load the relevant rule files for guidance.
+`,
+		};
+	});
+}

package/examples/extensions/commands.ts

@@ -0,0 +1,72 @@
+/**
+ * Commands Extension
+ *
+ * Demonstrates the threadwell.getCommands() API by providing a /commands command
+ * that lists all available slash commands in the current session.
+ *
+ * Usage:
+ * 1. Copy this file to ~/.threadwell/agent/extensions/ or your project's .threadwell/extensions/
+ * 2. Use /commands to see available commands
+ * 3. Use /commands extensions to filter by source
+ */
+
+import type { ExtensionAPI, SlashCommandInfo } from "threadwell";
+
+export default function commandsExtension(threadwell: ExtensionAPI) {
+	threadwell.registerCommand("commands", {
+		description: "List available slash commands",
+		getArgumentCompletions: (prefix) => {
+			const sources = ["extension", "prompt", "skill"];
+			const filtered = sources.filter((s) => s.startsWith(prefix));
+			return filtered.length > 0 ? filtered.map((s) => ({ value: s, label: s })) : null;
+		},
+		handler: async (args, ctx) => {
+			const commands = threadwell.getCommands();
+			const sourceFilter = args.trim() as "extension" | "prompt" | "skill" | "";
+
+			// Filter by source if specified
+			const filtered = sourceFilter ? commands.filter((c) => c.source === sourceFilter) : commands;
+
+			if (filtered.length === 0) {
+				ctx.ui.notify(sourceFilter ? `No ${sourceFilter} commands found` : "No commands found", "info");
+				return;
+			}
+
+			// Build selection items grouped by source
+			const formatCommand = (cmd: SlashCommandInfo): string => {
+				const desc = cmd.description ? ` - ${cmd.description}` : "";
+				return `/${cmd.name}${desc}`;
+			};
+
+			const items: string[] = [];
+			const sources: Array<{ key: "extension" | "prompt" | "skill"; label: string }> = [
+				{ key: "extension", label: "Extensions" },
+				{ key: "prompt", label: "Prompts" },
+				{ key: "skill", label: "Skills" },
+			];
+
+			for (const { key, label } of sources) {
+				const cmds = filtered.filter((c) => c.source === key);
+				if (cmds.length > 0) {
+					items.push(`--- ${label} ---`);
+					items.push(...cmds.map(formatCommand));
+				}
+			}
+
+			// Show in a selector (user can scroll and see all commands)
+			const selected = await ctx.ui.select("Available Commands", items);
+
+			// If user selected a command (not a header), offer to show its path
+			if (selected && !selected.startsWith("---")) {
+				const cmdName = selected.split(" - ")[0].slice(1); // Remove leading /
+				const cmd = commands.find((c) => c.name === cmdName);
+				if (cmd?.sourceInfo.path) {
+					const showPath = await ctx.ui.confirm(cmd.name, `View source path?\n${cmd.sourceInfo.path}`);
+					if (showPath) {
+						ctx.ui.notify(cmd.sourceInfo.path, "info");
+					}
+				}
+			}
+		},
+	});
+}

package/examples/extensions/confirm-destructive.ts

@@ -0,0 +1,59 @@
+/**
+ * Confirm Destructive Actions Extension
+ *
+ * Prompts for confirmation before destructive session actions (clear, switch, branch).
+ * Demonstrates how to cancel session events using the before_* events.
+ */
+
+import type { ExtensionAPI, SessionBeforeSwitchEvent, SessionMessageEntry } from "threadwell";
+
+export default function (threadwell: ExtensionAPI) {
+	threadwell.on("session_before_switch", async (event: SessionBeforeSwitchEvent, ctx) => {
+		if (!ctx.hasUI) return;
+
+		if (event.reason === "new") {
+			const confirmed = await ctx.ui.confirm(
+				"Clear session?",
+				"This will delete all messages in the current session.",
+			);
+
+			if (!confirmed) {
+				ctx.ui.notify("Clear cancelled", "info");
+				return { cancel: true };
+			}
+			return;
+		}
+
+		// reason === "resume" - check if there are unsaved changes (messages since last assistant response)
+		const entries = ctx.sessionManager.getEntries();
+		const hasUnsavedWork = entries.some(
+			(e): e is SessionMessageEntry => e.type === "message" && e.message.role === "user",
+		);
+
+		if (hasUnsavedWork) {
+			const confirmed = await ctx.ui.confirm(
+				"Switch session?",
+				"You have messages in the current session. Switch anyway?",
+			);
+
+			if (!confirmed) {
+				ctx.ui.notify("Switch cancelled", "info");
+				return { cancel: true };
+			}
+		}
+	});
+
+	threadwell.on("session_before_fork", async (event, ctx) => {
+		if (!ctx.hasUI) return;
+
+		const choice = await ctx.ui.select(`Fork from entry ${event.entryId.slice(0, 8)}?`, [
+			"Yes, create fork",
+			"No, stay in current session",
+		]);
+
+		if (choice !== "Yes, create fork") {
+			ctx.ui.notify("Fork cancelled", "info");
+			return { cancel: true };
+		}
+	});
+}