ctb 1.0.0 → 1.2.1

package/src/handlers/commands.ts

@@ -6,11 +6,12 @@
 
 import { existsSync, statSync } from "node:fs";
 import type { Context } from "grammy";
-import { InlineKeyboard } from "grammy";
+import { InlineKeyboard, InputFile } from "grammy";
 import { isBookmarked, loadBookmarks, resolvePath } from "../bookmarks";
 import { ALLOWED_USERS, RESTART_FILE } from "../config";
 import { isAuthorized, isPathAllowed } from "../security";
 import { session } from "../session";
+import { startTypingIndicator } from "../utils";
 
 /**
  * /start - Show welcome message and status.
@@ -37,6 +38,7 @@ export async function handleStart(ctx: Context): Promise<void> {
 			`/resume - Resume last session\n` +
 			`/retry - Retry last message\n` +
 			`/cd - Change working directory\n` +
+			`/file - Download a file\n` +
 			`/bookmarks - Manage directory bookmarks\n` +
 			`/restart - Restart the bot\n\n` +
 			`<b>Tips:</b>\n` +
@@ -70,7 +72,24 @@ export async function handleNew(ctx: Context): Promise<void> {
 	// Clear session
 	await session.kill();
 
-	await ctx.reply("🆕 Session cleared. Next message starts fresh.");
+	// Get context info
+	const username = process.env.USER || process.env.USERNAME || "unknown";
+	const workDir = session.workingDir;
+	const now = new Date().toLocaleString("en-US", {
+		weekday: "short",
+		month: "short",
+		day: "numeric",
+		hour: "2-digit",
+		minute: "2-digit",
+	});
+
+	await ctx.reply(
+		`🆕 Session cleared. Next message starts fresh.\n\n` +
+			`👤 ${username}\n` +
+			`📁 <code>${workDir}</code>\n` +
+			`🕐 ${now}`,
+		{ parse_mode: "HTML" },
+	);
 }
 
 /**
@@ -274,6 +293,267 @@ export async function handleRetry(ctx: Context): Promise<void> {
 	await handleText(fakeCtx);
 }
 
+/**
+ * /skill - Invoke a Claude Code skill.
+ */
+export async function handleSkill(ctx: Context): Promise<void> {
+	const userId = ctx.from?.id;
+
+	if (!isAuthorized(userId, ALLOWED_USERS)) {
+		await ctx.reply("Unauthorized.");
+		return;
+	}
+
+	// Get the skill name and args from command
+	const text = ctx.message?.text || "";
+	const match = text.match(/^\/skill\s+(\S+)(?:\s+(.*))?$/);
+
+	if (!match) {
+		await ctx.reply(
+			`🎯 <b>Invoke Skill</b>\n\n` +
+				`Usage: <code>/skill &lt;name&gt; [args]</code>\n\n` +
+				`Examples:\n` +
+				`• <code>/skill commit</code>\n` +
+				`• <code>/skill review-pr 123</code>\n` +
+				`• <code>/skill map</code>`,
+			{ parse_mode: "HTML" },
+		);
+		return;
+	}
+
+	const skillName = match[1] ?? "";
+	const skillArgs = match[2] || "";
+
+	// Build the skill command (Claude Code format: /skill_name args)
+	const skillCommand = skillArgs
+		? `/${skillName} ${skillArgs}`
+		: `/${skillName}`;
+
+	// Send to Claude via handleText
+	const { handleText } = await import("./text");
+	const fakeCtx = {
+		...ctx,
+		message: {
+			...ctx.message,
+			text: skillCommand,
+		},
+	} as Context;
+
+	await handleText(fakeCtx);
+}
+
+/**
+ * /model - Switch between models.
+ */
+export async function handleModel(ctx: Context): Promise<void> {
+	const userId = ctx.from?.id;
+
+	if (!isAuthorized(userId, ALLOWED_USERS)) {
+		await ctx.reply("Unauthorized.");
+		return;
+	}
+
+	const text = ctx.message?.text || "";
+	const match = text.match(/^\/model\s+(\w+)$/i);
+
+	if (!match) {
+		const current = session.currentModel;
+		await ctx.reply(
+			`🤖 <b>Model Selection</b>\n\n` +
+				`Current: <b>${current}</b>\n\n` +
+				`Usage: <code>/model &lt;name&gt;</code>\n\n` +
+				`Available:\n` +
+				`• <code>/model sonnet</code> - Fast, balanced\n` +
+				`• <code>/model opus</code> - Most capable\n` +
+				`• <code>/model haiku</code> - Fastest, cheapest`,
+			{ parse_mode: "HTML" },
+		);
+		return;
+	}
+
+	const modelName = match[1]?.toLowerCase();
+	if (modelName !== "sonnet" && modelName !== "opus" && modelName !== "haiku") {
+		await ctx.reply(
+			`❌ Unknown model: ${modelName}\n\nUse: sonnet, opus, or haiku`,
+		);
+		return;
+	}
+
+	session.currentModel = modelName;
+	await ctx.reply(`🤖 Switched to <b>${modelName}</b>`, { parse_mode: "HTML" });
+}
+
+/**
+ * /cost - Show token usage and estimated cost.
+ */
+export async function handleCost(ctx: Context): Promise<void> {
+	const userId = ctx.from?.id;
+
+	if (!isAuthorized(userId, ALLOWED_USERS)) {
+		await ctx.reply("Unauthorized.");
+		return;
+	}
+
+	const cost = session.estimateCost();
+	const formatNum = (n: number) => n.toLocaleString();
+	const formatCost = (n: number) => `$${n.toFixed(4)}`;
+
+	await ctx.reply(
+		`💰 <b>Session Usage</b>\n\n` +
+			`Model: <b>${session.currentModel}</b>\n\n` +
+			`<b>Tokens:</b>\n` +
+			`• Input: ${formatNum(session.totalInputTokens)}\n` +
+			`• Output: ${formatNum(session.totalOutputTokens)}\n` +
+			`• Cache read: ${formatNum(session.totalCacheReadTokens)}\n\n` +
+			`<b>Estimated Cost:</b>\n` +
+			`• Input: ${formatCost(cost.inputCost)}\n` +
+			`• Output: ${formatCost(cost.outputCost)}\n` +
+			`• Total: <b>${formatCost(cost.total)}</b>`,
+		{ parse_mode: "HTML" },
+	);
+}
+
+/**
+ * /think - Force extended thinking for next message.
+ */
+export async function handleThink(ctx: Context): Promise<void> {
+	const userId = ctx.from?.id;
+
+	if (!isAuthorized(userId, ALLOWED_USERS)) {
+		await ctx.reply("Unauthorized.");
+		return;
+	}
+
+	const text = ctx.message?.text || "";
+	const match = text.match(/^\/think\s+(\w+)$/i);
+
+	let tokens: number;
+	let label: string;
+
+	if (!match) {
+		// Default to deep thinking
+		tokens = 50000;
+		label = "deep (50K tokens)";
+	} else {
+		const level = match[1]?.toLowerCase();
+		if (level === "off" || level === "0") {
+			tokens = 0;
+			label = "off";
+		} else if (level === "normal" || level === "10k") {
+			tokens = 10000;
+			label = "normal (10K tokens)";
+		} else if (level === "deep" || level === "50k") {
+			tokens = 50000;
+			label = "deep (50K tokens)";
+		} else {
+			await ctx.reply(`❌ Unknown level: ${level}\n\nUse: off, normal, deep`);
+			return;
+		}
+	}
+
+	session.forceThinking = tokens;
+	await ctx.reply(`🧠 Next message will use <b>${label}</b> thinking`, {
+		parse_mode: "HTML",
+	});
+}
+
+/**
+ * /plan - Toggle planning mode.
+ */
+export async function handlePlan(ctx: Context): Promise<void> {
+	const userId = ctx.from?.id;
+
+	if (!isAuthorized(userId, ALLOWED_USERS)) {
+		await ctx.reply("Unauthorized.");
+		return;
+	}
+
+	session.planMode = !session.planMode;
+
+	if (session.planMode) {
+		await ctx.reply(
+			`📋 <b>Plan mode ON</b>\n\n` +
+				`Claude will analyze and plan without executing tools.\n` +
+				`Use <code>/plan</code> again to exit.`,
+			{ parse_mode: "HTML" },
+		);
+	} else {
+		await ctx.reply(`📋 Plan mode OFF - Normal execution resumed`);
+	}
+}
+
+/**
+ * /compact - Request context compaction (sends a hint to Claude).
+ */
+export async function handleCompact(ctx: Context): Promise<void> {
+	const userId = ctx.from?.id;
+
+	if (!isAuthorized(userId, ALLOWED_USERS)) {
+		await ctx.reply("Unauthorized.");
+		return;
+	}
+
+	if (!session.isActive) {
+		await ctx.reply("❌ No active session to compact.");
+		return;
+	}
+
+	// Send a message that triggers Claude to compact
+	const { handleText } = await import("./text");
+	const fakeCtx = {
+		...ctx,
+		message: {
+			...ctx.message,
+			text: "/compact",
+		},
+	} as Context;
+
+	await handleText(fakeCtx);
+}
+
+/**
+ * /undo - Revert file changes to last checkpoint.
+ */
+export async function handleUndo(ctx: Context): Promise<void> {
+	const userId = ctx.from?.id;
+
+	if (!isAuthorized(userId, ALLOWED_USERS)) {
+		await ctx.reply("Unauthorized.");
+		return;
+	}
+
+	if (!session.isActive) {
+		await ctx.reply("❌ No active session.");
+		return;
+	}
+
+	if (!session.canUndo) {
+		await ctx.reply(
+			`❌ No checkpoints available.\n\n` +
+				`Checkpoints are created when you send messages.`,
+		);
+		return;
+	}
+
+	// Show progress
+	const typing = startTypingIndicator(ctx);
+	const statusMsg = await ctx.reply("⏪ Reverting files...");
+
+	try {
+		const [success, message] = await session.undo();
+
+		// Update status message with result
+		await ctx.api.editMessageText(
+			ctx.chat!.id,
+			statusMsg.message_id,
+			success ? message : `❌ ${message}`,
+			{ parse_mode: "HTML" },
+		);
+	} finally {
+		typing.stop();
+	}
+}
+
 /**
  * /cd - Change working directory.
  */
@@ -299,7 +579,8 @@ export async function handleCd(ctx: Context): Promise<void> {
 	}
 
 	const inputPath = (match[1] ?? "").trim();
-	const resolvedPath = resolvePath(inputPath);
+	// Resolve relative paths from current working directory
+	const resolvedPath = resolvePath(inputPath, session.workingDir);
 
 	// Validate path exists and is a directory
 	if (!existsSync(resolvedPath)) {
@@ -349,6 +630,139 @@ export async function handleCd(ctx: Context): Promise<void> {
 	);
 }
 
+/**
+ * Send a single file to the user. Returns error message or null on success.
+ */
+async function sendFile(
+	ctx: Context,
+	filePath: string,
+): Promise<string | null> {
+	// Resolve relative paths from current working directory
+	const resolvedPath = resolvePath(filePath, session.workingDir);
+
+	// Validate path exists
+	if (!existsSync(resolvedPath)) {
+		return `File not found: ${resolvedPath}`;
+	}
+
+	const stats = statSync(resolvedPath);
+	if (stats.isDirectory()) {
+		return `Cannot send directory: ${resolvedPath}`;
+	}
+
+	// Check if path is allowed
+	if (!isPathAllowed(resolvedPath)) {
+		return `Access denied: ${resolvedPath}`;
+	}
+
+	// Check file size (Telegram limit is 50MB for bots)
+	const MAX_FILE_SIZE = 50 * 1024 * 1024;
+	if (stats.size > MAX_FILE_SIZE) {
+		const sizeMB = (stats.size / (1024 * 1024)).toFixed(1);
+		return `File too large: ${resolvedPath} (${sizeMB}MB, max 50MB)`;
+	}
+
+	// Send the file
+	try {
+		const filename = resolvedPath.split("/").pop() || "file";
+		await ctx.replyWithDocument(new InputFile(resolvedPath, filename));
+		return null;
+	} catch (error) {
+		const errMsg = error instanceof Error ? error.message : String(error);
+		return `Failed to send: ${errMsg}`;
+	}
+}
+
+/**
+ * /file - Send a file to the user.
+ * Without arguments: auto-detect file paths from last bot response.
+ */
+export async function handleFile(ctx: Context): Promise<void> {
+	const userId = ctx.from?.id;
+
+	if (!isAuthorized(userId, ALLOWED_USERS)) {
+		await ctx.reply("Unauthorized.");
+		return;
+	}
+
+	// Get the path argument from command
+	const text = ctx.message?.text || "";
+	const match = text.match(/^\/file\s+(.+)$/);
+
+	// If no argument, try to auto-detect from last bot response
+	if (!match) {
+		if (!session.lastBotResponse) {
+			await ctx.reply(
+				`📎 <b>Download File</b>\n\n` +
+					`Usage: <code>/file &lt;filepath&gt;</code>\n` +
+					`Or just <code>/file</code> to send files from the last response.\n\n` +
+					`No recent response to extract files from.`,
+				{ parse_mode: "HTML" },
+			);
+			return;
+		}
+
+		// Extract paths from <code> tags (response is HTML)
+		const codeMatches = session.lastBotResponse.matchAll(
+			/<code>([^<]+)<\/code>/g,
+		);
+		const candidates: string[] = [];
+		for (const m of codeMatches) {
+			const content = m[1]?.trim();
+			// Must have file extension (contains . followed by letters)
+			if (content && /\.[a-zA-Z0-9]+$/.test(content)) {
+				candidates.push(content);
+			}
+		}
+
+		// Deduplicate
+		const detected = [...new Set(candidates)];
+
+		if (detected.length === 0) {
+			await ctx.reply(
+				`📎 No file paths found in <code>&lt;code&gt;</code> tags.\n\n` +
+					`Usage: <code>/file &lt;filepath&gt;</code>`,
+				{ parse_mode: "HTML" },
+			);
+			return;
+		}
+
+		// Send each detected file
+		const errors: string[] = [];
+		let sent = 0;
+		for (const filePath of detected) {
+			const error = await sendFile(ctx, filePath);
+			if (error) {
+				errors.push(`${filePath}: ${error}`);
+			} else {
+				sent++;
+			}
+		}
+
+		// Report any errors
+		if (errors.length > 0) {
+			await ctx.reply(`⚠️ Some files failed:\n${errors.join("\n")}`, {
+				parse_mode: "HTML",
+			});
+		}
+
+		if (sent === 0 && errors.length > 0) {
+			// All failed, already reported above
+		} else if (sent > 0) {
+			// Success message optional, files speak for themselves
+		}
+
+		return;
+	}
+
+	// Explicit path provided
+	const inputPath = (match[1] ?? "").trim();
+	const error = await sendFile(ctx, inputPath);
+	if (error) {
+		await ctx.reply(`❌ ${error}`, { parse_mode: "HTML" });
+	}
+}
+
 /**
  * /bookmarks - List and manage bookmarks.
  */

package/src/handlers/index.ts

@@ -6,13 +6,21 @@ export { handleCallback } from "./callback";
 export {
 	handleBookmarks,
 	handleCd,
+	handleCompact,
+	handleCost,
+	handleFile,
+	handleModel,
 	handleNew,
+	handlePlan,
 	handleRestart,
 	handleResume,
 	handleRetry,
+	handleSkill,
 	handleStart,
 	handleStatus,
 	handleStop,
+	handleThink,
+	handleUndo,
 } from "./commands";
 export { handleDocument } from "./document";
 export { handlePhoto } from "./photo";