tidyf 1.0.0

package/src/lib/opencode.ts

@@ -0,0 +1,380 @@
+/**
+ * AI integration for tidy using @opencode-ai/sdk
+ */
+
+import * as p from "@clack/prompts";
+import {
+	createOpencode,
+	createOpencodeClient,
+	type OpencodeClient,
+} from "@opencode-ai/sdk";
+import { exec } from "child_process";
+import { join } from "path";
+import color from "picocolors";
+import { promisify } from "util";
+import type { ModelSelection } from "../types/config.ts";
+import type {
+	FileCategory,
+	FileMetadata,
+	FileMoveProposal,
+	OrganizationProposal,
+} from "../types/organizer.ts";
+import { fileExists } from "../utils/files.ts";
+import { expandPath, getRulesPrompt, resolveConfig } from "./config.ts";
+
+const execAsync = promisify(exec);
+
+// Server state
+let clientInstance: OpencodeClient | null = null;
+let serverInstance: { close: () => void } | null = null;
+let sessionId: string | null = null;
+
+/**
+ * Check if opencode CLI is installed
+ */
+async function isOpencodeInstalled(): Promise<boolean> {
+	try {
+		await execAsync("which opencode");
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Check if user is authenticated with opencode
+ */
+async function checkAuth(client: OpencodeClient): Promise<boolean> {
+	try {
+		const config = await client.config.get();
+		return !!config;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Get or create the Opencode client
+ * Tries to connect to existing server first, spawns new one if needed
+ */
+export async function getClient(): Promise<OpencodeClient> {
+	if (clientInstance) {
+		return clientInstance;
+	}
+
+	// Try connecting to existing server first
+	try {
+		const client = createOpencodeClient({
+			baseUrl: "http://localhost:4096",
+		});
+		// Test connection
+		await client.config.get();
+		clientInstance = client;
+		return client;
+	} catch {
+		// No existing server, need to spawn one
+	}
+
+	// Check if opencode is installed
+	if (!(await isOpencodeInstalled())) {
+		p.log.error("OpenCode CLI is not installed");
+		p.log.info(
+			`Install it with: ${color.cyan("npm install -g opencode")} or ${color.cyan("brew install sst/tap/opencode")}`,
+		);
+		process.exit(1);
+	}
+
+	// Spawn new server
+	try {
+		const opencode = await createOpencode({
+			timeout: 10000,
+		});
+
+		clientInstance = opencode.client;
+		serverInstance = opencode.server;
+
+		// Check authentication
+		if (!(await checkAuth(opencode.client))) {
+			p.log.warn("Not authenticated with OpenCode");
+			p.log.info(`Run ${color.cyan("opencode auth")} to authenticate`);
+			process.exit(1);
+		}
+
+		// Clean up server on process exit
+		process.on("exit", () => {
+			serverInstance?.close();
+		});
+		process.on("SIGINT", () => {
+			serverInstance?.close();
+			process.exit(0);
+		});
+		process.on("SIGTERM", () => {
+			serverInstance?.close();
+			process.exit(0);
+		});
+
+		return opencode.client;
+	} catch (error: any) {
+		p.log.error(`Failed to start OpenCode server: ${error.message}`);
+		p.log.info(`Make sure OpenCode is installed and configured correctly`);
+		process.exit(1);
+	}
+}
+
+/**
+ * Create a new session for file analysis
+ */
+export async function createSession(): Promise<string> {
+	const opencodeClient = await getClient();
+	const session = await opencodeClient.session.create();
+	sessionId = session.data?.id ?? "";
+	return sessionId;
+}
+
+/**
+ * Get current session ID or create one
+ */
+export async function getSessionId(): Promise<string> {
+	if (!sessionId) {
+		return createSession();
+	}
+	return sessionId;
+}
+
+/**
+ * Clean up resources
+ */
+export function cleanup(): void {
+	if (sessionId && clientInstance) {
+		// Attempt to abort/clean up the session
+		clientInstance.session.abort({ path: { id: sessionId } }).catch(() => {
+			// Ignore errors during cleanup
+		});
+	}
+	sessionId = null;
+	serverInstance?.close();
+	serverInstance = null;
+	clientInstance = null;
+}
+
+/**
+ * Options for analyzing files
+ */
+export interface AnalyzeFilesOptions {
+	/** Files to analyze */
+	files: FileMetadata[];
+	/** Target directory for organized files */
+	targetDir: string;
+	/** Additional instructions from user */
+	instructions?: string;
+	/** Model override */
+	model?: ModelSelection;
+}
+
+/**
+ * Format file metadata for AI prompt
+ */
+function formatFilesForPrompt(files: FileMetadata[]): string {
+	const formatted = files.map((f) => ({
+		name: f.name,
+		extension: f.extension,
+		size: f.size,
+		mimeType: f.mimeType,
+		modifiedAt: f.modifiedAt.toISOString(),
+		contentPreview: f.contentPreview?.slice(0, 500), // Limit preview size
+	}));
+
+	return JSON.stringify(formatted, null, 2);
+}
+
+/**
+ * Parse AI response into OrganizationProposal
+ */
+function parseAIResponse(
+	response: string,
+	files: FileMetadata[],
+	targetDir: string,
+): OrganizationProposal {
+	// Try to extract JSON from the response
+	let jsonStr = response;
+
+	// Try to find JSON in the response if wrapped in text
+	const jsonMatch = response.match(/\{[\s\S]*\}/);
+	if (jsonMatch) {
+		jsonStr = jsonMatch[0];
+	}
+
+	try {
+		const parsed = JSON.parse(jsonStr);
+
+		// Build a map of files by name for lookup
+		const fileMap = new Map<string, FileMetadata>();
+		for (const file of files) {
+			fileMap.set(file.name, file);
+		}
+
+		const proposals: FileMoveProposal[] = [];
+		const uncategorized: FileMetadata[] = [];
+
+		// Process proposals from AI
+		if (parsed.proposals && Array.isArray(parsed.proposals)) {
+			for (const p of parsed.proposals) {
+				const fileName = p.file || p.filename || p.name;
+				const file = fileMap.get(fileName);
+
+				if (!file) {
+					continue;
+				}
+
+				// Remove from map to track processed files
+				fileMap.delete(fileName);
+
+				const destination = join(
+					expandPath(targetDir),
+					p.destination || p.suggestedPath || "",
+					file.name,
+				);
+
+				const category: FileCategory = {
+					name: p.category?.name || "Other",
+					subcategory: p.category?.subcategory,
+					suggestedPath: p.destination || p.category?.suggestedPath || "",
+					confidence: p.category?.confidence || 0.5,
+					reasoning: p.category?.reasoning || p.reasoning || "",
+				};
+
+				proposals.push({
+					sourcePath: file.path,
+					file,
+					destination,
+					category,
+					conflictExists: false, // Will be checked later
+				});
+			}
+		}
+
+		// Process uncategorized files
+		if (parsed.uncategorized && Array.isArray(parsed.uncategorized)) {
+			for (const fileName of parsed.uncategorized) {
+				const file = fileMap.get(fileName);
+				if (file) {
+					uncategorized.push(file);
+					fileMap.delete(fileName);
+				}
+			}
+		}
+
+		// Any remaining files in the map are also uncategorized
+		for (const file of fileMap.values()) {
+			uncategorized.push(file);
+		}
+
+		return {
+			proposals,
+			strategy: parsed.strategy || parsed.overall_reasoning || "",
+			uncategorized,
+			analyzedAt: new Date(),
+		};
+	} catch {
+		// If parsing fails, treat all files as uncategorized
+		return {
+			proposals: [],
+			strategy: "Failed to parse AI response",
+			uncategorized: [...files],
+			analyzedAt: new Date(),
+		};
+	}
+}
+
+/**
+ * Check for file conflicts in proposals
+ */
+export async function checkConflicts(
+	proposal: OrganizationProposal,
+): Promise<OrganizationProposal> {
+	const updatedProposals = await Promise.all(
+		proposal.proposals.map(async (p) => ({
+			...p,
+			conflictExists: await fileExists(p.destination),
+		})),
+	);
+
+	return {
+		...proposal,
+		proposals: updatedProposals,
+	};
+}
+
+/**
+ * Analyze files using AI
+ */
+export async function analyzeFiles(
+	options: AnalyzeFilesOptions,
+): Promise<OrganizationProposal> {
+	const { files, targetDir, instructions, model } = options;
+
+	if (files.length === 0) {
+		return {
+			proposals: [],
+			strategy: "No files to analyze",
+			uncategorized: [],
+			analyzedAt: new Date(),
+		};
+	}
+
+	const opencodeClient = await getClient();
+	const sid = await getSessionId();
+
+	// Get configuration
+	const config = resolveConfig();
+	const rulesPrompt = getRulesPrompt();
+
+	// Build the prompt
+	const filesJson = formatFilesForPrompt(files);
+
+	const userPrompt = `
+Analyze the following files and organize them according to the rules.
+
+Target directory: ${targetDir}
+
+${instructions ? `Additional instructions: ${instructions}\n` : ""}
+Files to organize:
+${filesJson}
+
+Respond with ONLY a JSON object (no markdown code blocks) following the format specified in the rules.
+`;
+
+	// Send the message and get response using session.prompt
+	const response = await opencodeClient.session.prompt({
+		path: { id: sid },
+		body: {
+			system: rulesPrompt,
+			model: {
+				providerID: model?.provider || config.organizer?.provider || "opencode",
+				modelID: model?.model || config.organizer?.model || "claude-sonnet-4-5",
+			},
+			parts: [{ type: "text", text: userPrompt }],
+		},
+	});
+
+	// Extract the text content from the response
+	const parts = response.data?.parts || [];
+	const responseText = parts
+		.filter((p) => p.type === "text" && "text" in p)
+		.map((p) => (p as { type: "text"; text: string }).text)
+		.join("");
+
+	// Parse the response
+	const proposal = parseAIResponse(responseText, files, targetDir);
+
+	// Check for conflicts
+	return checkConflicts(proposal);
+}
+
+/**
+ * Get available models
+ */
+export async function getAvailableModels() {
+	const client = await getClient();
+	return client.config.providers();
+}

package/src/lib/scanner.ts

@@ -0,0 +1,296 @@
+/**
+ * File scanning utilities for tidy
+ */
+
+import { readdir, stat, readFile } from "fs/promises";
+import { join, extname, basename } from "path";
+import { lookup as lookupMimeType } from "mime-types";
+import type { FileMetadata } from "../types/organizer.ts";
+import { shouldIgnore } from "./config.ts";
+import { isDirectory, isFile } from "../utils/files.ts";
+
+/**
+ * Options for scanning a directory
+ */
+export interface ScanOptions {
+  /** Scan subdirectories */
+  recursive?: boolean;
+  /** Max depth for recursive scan (0 = no limit) */
+  maxDepth?: number;
+  /** Patterns to ignore */
+  ignore?: string[];
+  /** Whether to read file content preview */
+  readContent?: boolean;
+  /** Max file size to read content (bytes) */
+  maxContentSize?: number;
+}
+
+/**
+ * Scan a directory and return metadata for all files
+ */
+export async function scanDirectory(
+  dirPath: string,
+  options: ScanOptions = {}
+): Promise<FileMetadata[]> {
+  const {
+    recursive = false,
+    maxDepth = 1,
+    ignore = [],
+    readContent = false,
+    maxContentSize = 10240,
+  } = options;
+
+  return scanDirectoryInternal(dirPath, {
+    recursive,
+    maxDepth,
+    ignore,
+    readContent,
+    maxContentSize,
+    currentDepth: 0,
+  });
+}
+
+interface InternalScanOptions extends ScanOptions {
+  currentDepth: number;
+}
+
+async function scanDirectoryInternal(
+  dirPath: string,
+  options: InternalScanOptions
+): Promise<FileMetadata[]> {
+  const files: FileMetadata[] = [];
+
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+
+      // Check if should be ignored
+      if (shouldIgnore(entry.name, options.ignore || [])) {
+        continue;
+      }
+
+      if (entry.isFile()) {
+        const metadata = await getFileMetadata(fullPath, {
+          readContent: options.readContent,
+          maxContentSize: options.maxContentSize,
+        });
+        if (metadata) {
+          files.push(metadata);
+        }
+      } else if (
+        entry.isDirectory() &&
+        options.recursive &&
+        ((options.maxDepth ?? 0) === 0 || options.currentDepth < (options.maxDepth ?? 0))
+      ) {
+        // Recursively scan subdirectory
+        const subFiles = await scanDirectoryInternal(fullPath, {
+          ...options,
+          currentDepth: options.currentDepth + 1,
+        });
+        files.push(...subFiles);
+      }
+    }
+  } catch (error: any) {
+    // Silently skip directories we can't read
+    console.error(`Warning: Could not scan ${dirPath}: ${error.message}`);
+  }
+
+  return files;
+}
+
+/**
+ * Get metadata for a single file
+ */
+export async function getFileMetadata(
+  filePath: string,
+  options: { readContent?: boolean; maxContentSize?: number } = {}
+): Promise<FileMetadata | null> {
+  try {
+    const stats = await stat(filePath);
+
+    if (!stats.isFile()) {
+      return null;
+    }
+
+    const name = basename(filePath);
+    const extension = extname(name).slice(1).toLowerCase();
+    const mimeType = lookupMimeType(name) || undefined;
+
+    let contentPreview: string | undefined;
+    if (
+      options.readContent &&
+      stats.size <= (options.maxContentSize || 10240)
+    ) {
+      contentPreview = await readFilePreview(
+        filePath,
+        options.maxContentSize || 10240,
+        mimeType
+      );
+    }
+
+    return {
+      path: filePath,
+      name,
+      extension,
+      size: stats.size,
+      modifiedAt: stats.mtime,
+      createdAt: stats.birthtime,
+      mimeType,
+      contentPreview,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read a preview of a file's content
+ */
+export async function readFilePreview(
+  filePath: string,
+  maxSize: number,
+  mimeType?: string
+): Promise<string | undefined> {
+  try {
+    // Only read text-based files
+    if (!isTextFile(mimeType)) {
+      return undefined;
+    }
+
+    const buffer = Buffer.alloc(maxSize);
+    const file = await readFile(filePath);
+    const bytesToRead = Math.min(file.length, maxSize);
+    file.copy(buffer, 0, 0, bytesToRead);
+
+    const content = buffer.toString("utf-8", 0, bytesToRead);
+
+    // Clean up the content - first 20 lines
+    const lines = content.split("\n").slice(0, 20);
+    return lines.join("\n");
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Check if a file is text-based (readable)
+ */
+function isTextFile(mimeType?: string): boolean {
+  if (!mimeType) return false;
+
+  const textMimeTypes = [
+    "text/",
+    "application/json",
+    "application/javascript",
+    "application/typescript",
+    "application/xml",
+    "application/x-yaml",
+    "application/x-sh",
+    "application/x-python",
+  ];
+
+  return textMimeTypes.some(
+    (type) => mimeType.startsWith(type) || mimeType === type
+  );
+}
+
+/**
+ * Get file category based on extension
+ */
+export function getFileCategory(extension: string): string {
+  const categories: Record<string, string[]> = {
+    Documents: [
+      "pdf",
+      "doc",
+      "docx",
+      "txt",
+      "rtf",
+      "odt",
+      "md",
+      "pages",
+    ],
+    Spreadsheets: ["xls", "xlsx", "csv", "ods", "numbers"],
+    Presentations: ["ppt", "pptx", "key", "odp"],
+    Images: [
+      "jpg",
+      "jpeg",
+      "png",
+      "gif",
+      "svg",
+      "webp",
+      "heic",
+      "ico",
+      "bmp",
+      "tiff",
+      "psd",
+      "ai",
+      "sketch",
+      "fig",
+    ],
+    Videos: ["mp4", "mov", "avi", "mkv", "webm", "wmv", "flv", "m4v"],
+    Audio: ["mp3", "wav", "flac", "aac", "ogg", "m4a", "wma"],
+    Archives: ["zip", "rar", "7z", "tar", "gz", "bz2", "xz"],
+    Code: [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "py",
+      "rb",
+      "go",
+      "rs",
+      "java",
+      "c",
+      "cpp",
+      "h",
+      "hpp",
+      "cs",
+      "swift",
+      "kt",
+      "php",
+      "html",
+      "css",
+      "scss",
+      "less",
+      "json",
+      "xml",
+      "yaml",
+      "yml",
+      "toml",
+    ],
+    Applications: ["dmg", "pkg", "exe", "msi", "app", "apk", "ipa", "deb", "rpm"],
+    Ebooks: ["epub", "mobi", "azw", "azw3"],
+    Fonts: ["ttf", "otf", "woff", "woff2"],
+    Data: ["sql", "db", "sqlite"],
+  };
+
+  const ext = extension.toLowerCase();
+  for (const [category, extensions] of Object.entries(categories)) {
+    if (extensions.includes(ext)) {
+      return category;
+    }
+  }
+
+  return "Other";
+}
+
+/**
+ * Group files by their base category
+ */
+export function groupFilesByCategory(
+  files: FileMetadata[]
+): Record<string, FileMetadata[]> {
+  const groups: Record<string, FileMetadata[]> = {};
+
+  for (const file of files) {
+    const category = getFileCategory(file.extension);
+    if (!groups[category]) {
+      groups[category] = [];
+    }
+    groups[category].push(file);
+  }
+
+  return groups;
+}