Refactor out of utils

src/integrations/misc/export-markdown.ts

@@ -0,0 +1,94 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import os from "os"
+import * as path from "path"
+import * as vscode from "vscode"
+
+export async function downloadTask(dateTs: number, conversationHistory: Anthropic.MessageParam[]) {
+	// File name
+	const date = new Date(dateTs)
+	const month = date.toLocaleString("en-US", { month: "short" }).toLowerCase()
+	const day = date.getDate()
+	const year = date.getFullYear()
+	let hours = date.getHours()
+	const minutes = date.getMinutes().toString().padStart(2, "0")
+	const seconds = date.getSeconds().toString().padStart(2, "0")
+	const ampm = hours >= 12 ? "pm" : "am"
+	hours = hours % 12
+	hours = hours ? hours : 12 // the hour '0' should be '12'
+	const fileName = `claude_dev_task_${month}-${day}-${year}_${hours}-${minutes}-${seconds}-${ampm}.md`
+
+	// Generate markdown
+	const markdownContent = conversationHistory
+		.map((message) => {
+			const role = message.role === "user" ? "**User:**" : "**Assistant:**"
+			const content = Array.isArray(message.content)
+				? message.content.map((block) => formatContentBlockToMarkdown(block, conversationHistory)).join("\n")
+				: message.content
+			return `${role}\n\n${content}\n\n`
+		})
+		.join("---\n\n")
+
+	// Prompt user for save location
+	const saveUri = await vscode.window.showSaveDialog({
+		filters: { Markdown: ["md"] },
+		defaultUri: vscode.Uri.file(path.join(os.homedir(), "Downloads", fileName)),
+	})
+
+	if (saveUri) {
+		// Write content to the selected location
+		await vscode.workspace.fs.writeFile(saveUri, Buffer.from(markdownContent))
+		vscode.window.showTextDocument(saveUri, { preview: true })
+	}
+}
+
+export function formatContentBlockToMarkdown(
+	block:
+		| Anthropic.TextBlockParam
+		| Anthropic.ImageBlockParam
+		| Anthropic.ToolUseBlockParam
+		| Anthropic.ToolResultBlockParam,
+	messages: Anthropic.MessageParam[]
+): string {
+	switch (block.type) {
+		case "text":
+			return block.text
+		case "image":
+			return `[Image]`
+		case "tool_use":
+			let input: string
+			if (typeof block.input === "object" && block.input !== null) {
+				input = Object.entries(block.input)
+					.map(([key, value]) => `${key.charAt(0).toUpperCase() + key.slice(1)}: ${value}`)
+					.join("\n")
+			} else {
+				input = String(block.input)
+			}
+			return `[Tool Use: ${block.name}]\n${input}`
+		case "tool_result":
+			const toolName = findToolName(block.tool_use_id, messages)
+			if (typeof block.content === "string") {
+				return `[${toolName}${block.is_error ? " (Error)" : ""}]\n${block.content}`
+			} else if (Array.isArray(block.content)) {
+				return `[${toolName}${block.is_error ? " (Error)" : ""}]\n${block.content
+					.map((contentBlock) => formatContentBlockToMarkdown(contentBlock, messages))
+					.join("\n")}`
+			} else {
+				return `[${toolName}${block.is_error ? " (Error)" : ""}]`
+			}
+		default:
+			return "[Unexpected content type]"
+	}
+}
+
+function findToolName(toolCallId: string, messages: Anthropic.MessageParam[]): string {
+	for (const message of messages) {
+		if (Array.isArray(message.content)) {
+			for (const block of message.content) {
+				if (block.type === "tool_use" && block.id === toolCallId) {
+					return block.name
+				}
+			}
+		}
+	}
+	return "Unknown Tool"
+}

src/integrations/misc/extract-text.ts

@@ -0,0 +1,55 @@
+import * as path from "path"
+// @ts-ignore-next-line
+import pdf from "pdf-parse/lib/pdf-parse"
+import mammoth from "mammoth"
+import fs from "fs/promises"
+import { isBinaryFile } from "isbinaryfile"
+
+export async function extractTextFromFile(filePath: string): Promise<string> {
+	try {
+		await fs.access(filePath)
+	} catch (error) {
+		throw new Error(`File not found: ${filePath}`)
+	}
+	const fileExtension = path.extname(filePath).toLowerCase()
+	switch (fileExtension) {
+		case ".pdf":
+			return extractTextFromPDF(filePath)
+		case ".docx":
+			return extractTextFromDOCX(filePath)
+		case ".ipynb":
+			return extractTextFromIPYNB(filePath)
+		default:
+			const isBinary = await isBinaryFile(filePath).catch(() => false)
+			if (!isBinary) {
+				return await fs.readFile(filePath, "utf8")
+			} else {
+				throw new Error(`Cannot read text for file type: ${fileExtension}`)
+			}
+	}
+}
+
+async function extractTextFromPDF(filePath: string): Promise<string> {
+	const dataBuffer = await fs.readFile(filePath)
+	const data = await pdf(dataBuffer)
+	return data.text
+}
+
+async function extractTextFromDOCX(filePath: string): Promise<string> {
+	const result = await mammoth.extractRawText({ path: filePath })
+	return result.value
+}
+
+async function extractTextFromIPYNB(filePath: string): Promise<string> {
+	const data = await fs.readFile(filePath, "utf8")
+	const notebook = JSON.parse(data)
+	let extractedText = ""
+
+	for (const cell of notebook.cells) {
+		if ((cell.cell_type === "markdown" || cell.cell_type === "code") && cell.source) {
+			extractedText += cell.source.join("\n") + "\n"
+		}
+	}
+
+	return extractedText
+}

src/integrations/misc/open-file.ts

@@ -0,0 +1,51 @@
+import * as path from "path"
+import * as os from "os"
+import * as vscode from "vscode"
+import { arePathsEqual } from "../../utils/path-helpers"
+
+export async function openImage(dataUri: string) {
+	const matches = dataUri.match(/^data:image\/([a-zA-Z]+);base64,(.+)$/)
+	if (!matches) {
+		vscode.window.showErrorMessage("Invalid data URI format")
+		return
+	}
+	const [, format, base64Data] = matches
+	const imageBuffer = Buffer.from(base64Data, "base64")
+	const tempFilePath = path.join(os.tmpdir(), `temp_image_${Date.now()}.${format}`)
+	try {
+		await vscode.workspace.fs.writeFile(vscode.Uri.file(tempFilePath), imageBuffer)
+		await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(tempFilePath))
+	} catch (error) {
+		vscode.window.showErrorMessage(`Error opening image: ${error}`)
+	}
+}
+
+export async function openFile(absolutePath: string) {
+	try {
+		const uri = vscode.Uri.file(absolutePath)
+
+		// Check if the document is already open in a tab group that's not in the active editor's column. If it is, then close it (if not dirty) so that we don't duplicate tabs
+		try {
+			for (const group of vscode.window.tabGroups.all) {
+				const existingTab = group.tabs.find(
+					(tab) => tab.input instanceof vscode.TabInputText && arePathsEqual(tab.input.uri.fsPath, uri.fsPath)
+				)
+				if (existingTab) {
+					const activeColumn = vscode.window.activeTextEditor?.viewColumn
+					const tabColumn = vscode.window.tabGroups.all.find((group) =>
+						group.tabs.includes(existingTab)
+					)?.viewColumn
+					if (activeColumn && activeColumn !== tabColumn && !existingTab.isDirty) {
+						await vscode.window.tabGroups.close(existingTab)
+					}
+					break
+				}
+			}
+		} catch {} // not essential, sometimes tab operations fail
+
+		const document = await vscode.workspace.openTextDocument(uri)
+		await vscode.window.showTextDocument(document, { preview: false })
+	} catch (error) {
+		vscode.window.showErrorMessage(`Could not open file!`)
+	}
+}

src/integrations/misc/process-images.ts

@@ -0,0 +1,45 @@
+import * as vscode from "vscode"
+import fs from "fs/promises"
+import * as path from "path"
+
+export async function selectImages(): Promise<string[]> {
+	const options: vscode.OpenDialogOptions = {
+		canSelectMany: true,
+		openLabel: "Select",
+		filters: {
+			Images: ["png", "jpg", "jpeg", "webp"], // supported by anthropic and openrouter
+		},
+	}
+
+	const fileUris = await vscode.window.showOpenDialog(options)
+
+	if (!fileUris || fileUris.length === 0) {
+		return []
+	}
+
+	return await Promise.all(
+		fileUris.map(async (uri) => {
+			const imagePath = uri.fsPath
+			const buffer = await fs.readFile(imagePath)
+			const base64 = buffer.toString("base64")
+			const mimeType = getMimeType(imagePath)
+			const dataUrl = `data:${mimeType};base64,${base64}`
+			return dataUrl
+		})
+	)
+}
+
+function getMimeType(filePath: string): string {
+	const ext = path.extname(filePath).toLowerCase()
+	switch (ext) {
+		case ".png":
+			return "image/png"
+		case ".jpeg":
+		case ".jpg":
+			return "image/jpeg"
+		case ".webp":
+			return "image/webp"
+		default:
+			throw new Error(`Unsupported file type: ${ext}`)
+	}
+}