tidyf 1.0.0 → 1.0.1

package/README.md

@@ -2,24 +2,52 @@
 
 AI-powered file organizer CLI using [opencode.ai](https://opencode.ai)
 
-```
-┌   tidyf
+```text
+┌   tidyf 
 │
-◆  Scanning ~/Downloads...
-│    Found 12 files
+●  Source: ~/Downloads
 │
-◇  Analyzing files with AI...
+●  Target: ~/Downloads/Organized
 │
-◆  Organization proposal:
-│    📄 report-2024.pdf → Documents/Work
-│    🖼️  screenshot.png → Images/Screenshots
-│    📦 project.zip → Archives
+◇  Found 15 files
+│
+●  Total size: 79 MB
+│
+◇  Analysis complete
+│
+●  Proposed organization for 15 files:
+│
+│  Strategy: Primary categorization by file type and MIME type, secondary categorization 
+│  by filename context and naming patterns. Documents go to Work, books 
+│  to Education, and camera images to Photos.
+│
+●  📄 Documents (9 files)
+│
+│  [1] 📄 financial-report.pdf (596 KB)
+│      → ~/Downloads/Organized/Documents/Work/financial-report.pdf
+│      📄 Documents/Work 90%
+│      Document with financial context and report keywords
+│
+│  [2] 📄 research-paper.pdf (448.6 KB)
+│      → ~/Downloads/Organized/Documents/Education/research-paper.pdf
+│      📄 Documents/Education 85%
+│      Technical document, appears to be educational content
 │
-◆  What would you like to do?
-│  ● Apply all
+●  🖼️ Images (4 files)
+│
+│  [12] 🖼️ vacation-photo.jpg (361.1 KB)
+│      → ~/Downloads/Organized/Images/Photos/vacation-photo.jpg
+│      🖼️ Images/Photos 95%
+│      Image with metadata indicating it was taken with a camera
+│
+■  What would you like to do?
+│  ● Apply all 15 moves
 │  ○ Select individually
+│  ○ Regenerate analysis
+│  ○ Regenerate analysis (different model)
 │  ○ Cancel
-└
+│
+└  Organization complete!
 ```
 
 ## Features
@@ -191,6 +219,11 @@ Edit this file to customize AI behavior for your workflow.
 2. **Analyzes with AI** - Sends file info to AI with your configured rules
 3. **Proposes organization** - Shows categorization with confidence levels
 4. **Confirms with you** - Presents interactive UI for approval
+   - Apply all moves
+   - View file details
+   - Regenerate analysis (optional: with different instructions)
+   - Regenerate analysis (different model) — choose another provider/model
+   - Cancel
 5. **Moves files** - Organizes files into target directory structure
 
 ## Examples
@@ -198,24 +231,68 @@ Edit this file to customize AI behavior for your workflow.
 ### Basic Organization
 
 ```bash
-$ tidyf ~/Downloads
-┌   tidyf
+$ tidyf
+┌   tidyf 
+│
+●  Source: ~/Downloads
+│
+●  Target: ~/Downloads/Organized
+│
+◇  Found 12 files
+│
+●  Total size: 45 MB
+│
+◇  Analysis complete
+│
+●  Proposed organization for 12 files:
+│
+│  Strategy: Primary categorization by file type and MIME type, secondary categorization 
+│  by filename context and naming patterns...
+│
+●  📄 Documents (5 files)
+│
+│  [1] 📄 project-proposal.pdf (245 KB)
+│      → ~/Downloads/Organized/Documents/Work/project-proposal.pdf
+│      📄 Documents/Work 95%
+│      Business document with project keywords
+│
+■  What would you like to do?
+│  ● Apply all 12 moves
+│  ○ Select individually
+│  ○ Cancel
+│
+└  Organization complete!
+```
+
+### Interactive Configuration
+
+```bash
+$ tidyf config
+┌   tidyf config 
+│
+●  Configuring global settings
+│
+│  Config: ~/.tidy/settings.json
+│
+◇  What would you like to configure?
+│  AI Model
+│
+◇  Fetched 2 providers
+│
+●  Current Model: opencode/big-pickle
+│
+◇  Select AI provider:
+│  OpenCode Zen
 │
-◆  Scanning ~/Downloads...
-│    Found 5 files
+◇  Select model:
+│  glm-4.7-free
 │
-◇  Analyzing files with AI...
+◆  Model set to opencode/glm-4.7-free
 │
-◆  Organization proposal:
-│    📄 invoice-2024.pdf → Documents/Receipts
-│    🖼️  vacation-photo.jpg → Images/Photos
-│    📦 backup.zip → Archives
-│    🎵 podcast.mp3 → Audio/Podcasts
-│    💻 installer.dmg → Applications/Installers
+◇  What would you like to configure?
+│  Done
 │
-◆  Apply these changes?
-│  ● Yes
-└
+└  Configuration saved!
 ```
 
 ### Watch Mode

package/dist/cli.js

@@ -18813,6 +18813,143 @@ function getStatusIndicator(status) {
   }
 }
 
+// src/commands/modelPicker.ts
+async function pickModel() {
+  const s = Y2();
+  s.start("Fetching available models from OpenCode...");
+  let providers = [];
+  try {
+    const response = await getAvailableModels();
+    if (response.error) {
+      throw new Error("Failed to fetch models");
+    }
+    providers = response.data?.providers || [];
+    s.stop(`Fetched ${providers.length} providers`);
+  } catch (error) {
+    s.stop("Failed to fetch models");
+    M2.error(error.message);
+    M2.warn("Falling back to manual entry.");
+  }
+  let providerId;
+  let modelName;
+  if (providers.length > 0) {
+    const providerOptions = providers.map((prov) => ({
+      value: prov.id,
+      label: prov.name || prov.id
+    }));
+    providerOptions.push({
+      value: "custom",
+      label: "Enter custom provider..."
+    });
+    const selectedProvider = await ve({
+      message: "Select AI provider:",
+      options: providerOptions
+    });
+    if (pD(selectedProvider)) {
+      return;
+    }
+    if (selectedProvider === "custom") {
+      const customProv = await he({
+        message: "Enter provider ID:",
+        placeholder: "opencode",
+        validate: (value) => {
+          if (!value)
+            return "Provider ID is required";
+        }
+      });
+      if (pD(customProv))
+        return;
+      providerId = customProv;
+      const customModel = await he({
+        message: "Enter model ID:",
+        placeholder: "gpt-4o",
+        validate: (value) => {
+          if (!value)
+            return "Model ID is required";
+        }
+      });
+      if (pD(customModel))
+        return;
+      modelName = customModel;
+    } else {
+      providerId = selectedProvider;
+      const providerData = providers.find((p2) => p2.id === providerId);
+      if (!providerData || !providerData.models) {
+        M2.warn(`No models found for provider ${providerId}, please enter manually.`);
+        const customModel = await he({
+          message: "Enter model ID:",
+          placeholder: "gpt-4o",
+          validate: (value) => {
+            if (!value)
+              return "Model ID is required";
+          }
+        });
+        if (pD(customModel))
+          return;
+        modelName = customModel;
+      } else {
+        let modelIds = [];
+        if (Array.isArray(providerData.models)) {
+          modelIds = providerData.models;
+        } else if (typeof providerData.models === "object") {
+          modelIds = Object.keys(providerData.models);
+        }
+        if (modelIds.length === 0) {
+          M2.warn(`No models found for provider ${providerId}`);
+          const customModel = await he({
+            message: "Enter model ID:"
+          });
+          if (pD(customModel))
+            return;
+          modelName = customModel;
+        } else {
+          const modelOptions = modelIds.map((model) => ({
+            value: model,
+            label: model
+          }));
+          modelOptions.push({
+            value: "custom",
+            label: "Enter custom model..."
+          });
+          const selectedModel = await ve({
+            message: "Select model:",
+            options: modelOptions
+          });
+          if (pD(selectedModel))
+            return;
+          if (selectedModel === "custom") {
+            const customModel = await he({
+              message: "Enter model ID:"
+            });
+            if (pD(customModel))
+              return;
+            modelName = customModel;
+          } else {
+            modelName = selectedModel;
+          }
+        }
+      }
+    }
+  } else {
+    const manualEntry = await he({
+      message: "Enter model (format: provider/model):",
+      placeholder: "opencode/gpt-4o",
+      validate: (value) => {
+        if (!value.includes("/")) {
+          return "Model must be in format: provider/model";
+        }
+      }
+    });
+    if (pD(manualEntry)) {
+      return;
+    }
+    const parts = manualEntry.split("/");
+    providerId = parts[0];
+    modelName = parts.slice(1).join("/");
+  }
+  return { provider: providerId, model: modelName };
+}
+
 // src/commands/organize.ts
 function displayProposal(proposal, index) {
   const icon = getFileIcon(proposal.file.name);
@@ -19000,6 +19137,11 @@ async function organizeCommand(options) {
             label: "Regenerate analysis",
             hint: "Ask AI to re-analyze with different instructions"
           },
+          {
+            value: "regenerate_with_model",
+            label: "Regenerate analysis (different model)",
+            hint: "Re-analyze using another provider/model"
+          },
           {
             value: "cancel",
             label: "Cancel"
@@ -19043,6 +19185,34 @@ async function organizeCommand(options) {
           }
           break;
         }
+        case "regenerate_with_model": {
+          const newInstructions = await he({
+            message: "Enter additional instructions for AI (or press Enter to skip):",
+            placeholder: "e.g., Keep all PDFs together, sort images by date"
+          });
+          if (pD(newInstructions)) {
+            break;
+          }
+          const pickedModel = await pickModel();
+          if (!pickedModel) {
+            break;
+          }
+          spinner.start(`Re-analyzing with ${pickedModel.provider}/${pickedModel.model}...`);
+          try {
+            proposal = await analyzeFiles({
+              files,
+              targetDir: targetPath,
+              instructions: newInstructions || undefined,
+              model: pickedModel
+            });
+            spinner.stop("Analysis complete");
+            displayAllProposals(proposal);
+          } catch (error) {
+            spinner.stop("Analysis failed");
+            M2.error(error.message);
+          }
+          break;
+        }
       }
     }
   }

package/dist/index.js

@@ -16714,6 +16714,145 @@ function createWatcher(options) {
 // src/commands/organize.ts
 var import_picocolors4 = __toESM(require_picocolors(), 1);
 import { isAbsolute, resolve } from "path";
+
+// src/commands/modelPicker.ts
+async function pickModel() {
+  const s = Y2();
+  s.start("Fetching available models from OpenCode...");
+  let providers = [];
+  try {
+    const response = await getAvailableModels();
+    if (response.error) {
+      throw new Error("Failed to fetch models");
+    }
+    providers = response.data?.providers || [];
+    s.stop(`Fetched ${providers.length} providers`);
+  } catch (error) {
+    s.stop("Failed to fetch models");
+    M2.error(error.message);
+    M2.warn("Falling back to manual entry.");
+  }
+  let providerId;
+  let modelName;
+  if (providers.length > 0) {
+    const providerOptions = providers.map((prov) => ({
+      value: prov.id,
+      label: prov.name || prov.id
+    }));
+    providerOptions.push({
+      value: "custom",
+      label: "Enter custom provider..."
+    });
+    const selectedProvider = await ve({
+      message: "Select AI provider:",
+      options: providerOptions
+    });
+    if (pD(selectedProvider)) {
+      return;
+    }
+    if (selectedProvider === "custom") {
+      const customProv = await he({
+        message: "Enter provider ID:",
+        placeholder: "opencode",
+        validate: (value) => {
+          if (!value)
+            return "Provider ID is required";
+        }
+      });
+      if (pD(customProv))
+        return;
+      providerId = customProv;
+      const customModel = await he({
+        message: "Enter model ID:",
+        placeholder: "gpt-4o",
+        validate: (value) => {
+          if (!value)
+            return "Model ID is required";
+        }
+      });
+      if (pD(customModel))
+        return;
+      modelName = customModel;
+    } else {
+      providerId = selectedProvider;
+      const providerData = providers.find((p2) => p2.id === providerId);
+      if (!providerData || !providerData.models) {
+        M2.warn(`No models found for provider ${providerId}, please enter manually.`);
+        const customModel = await he({
+          message: "Enter model ID:",
+          placeholder: "gpt-4o",
+          validate: (value) => {
+            if (!value)
+              return "Model ID is required";
+          }
+        });
+        if (pD(customModel))
+          return;
+        modelName = customModel;
+      } else {
+        let modelIds = [];
+        if (Array.isArray(providerData.models)) {
+          modelIds = providerData.models;
+        } else if (typeof providerData.models === "object") {
+          modelIds = Object.keys(providerData.models);
+        }
+        if (modelIds.length === 0) {
+          M2.warn(`No models found for provider ${providerId}`);
+          const customModel = await he({
+            message: "Enter model ID:"
+          });
+          if (pD(customModel))
+            return;
+          modelName = customModel;
+        } else {
+          const modelOptions = modelIds.map((model) => ({
+            value: model,
+            label: model
+          }));
+          modelOptions.push({
+            value: "custom",
+            label: "Enter custom model..."
+          });
+          const selectedModel = await ve({
+            message: "Select model:",
+            options: modelOptions
+          });
+          if (pD(selectedModel))
+            return;
+          if (selectedModel === "custom") {
+            const customModel = await he({
+              message: "Enter model ID:"
+            });
+            if (pD(customModel))
+              return;
+            modelName = customModel;
+          } else {
+            modelName = selectedModel;
+          }
+        }
+      }
+    }
+  } else {
+    const manualEntry = await he({
+      message: "Enter model (format: provider/model):",
+      placeholder: "opencode/gpt-4o",
+      validate: (value) => {
+        if (!value.includes("/")) {
+          return "Model must be in format: provider/model";
+        }
+      }
+    });
+    if (pD(manualEntry)) {
+      return;
+    }
+    const parts = manualEntry.split("/");
+    providerId = parts[0];
+    modelName = parts.slice(1).join("/");
+  }
+  return { provider: providerId, model: modelName };
+}
+
+// src/commands/organize.ts
 function displayProposal(proposal, index) {
   const icon = getFileIcon(proposal.file.name);
   const size = import_picocolors4.default.dim(`(${formatFileSize(proposal.file.size)})`);
@@ -16900,6 +17039,11 @@ async function organizeCommand(options) {
             label: "Regenerate analysis",
             hint: "Ask AI to re-analyze with different instructions"
           },
+          {
+            value: "regenerate_with_model",
+            label: "Regenerate analysis (different model)",
+            hint: "Re-analyze using another provider/model"
+          },
           {
             value: "cancel",
             label: "Cancel"
@@ -16943,6 +17087,34 @@ async function organizeCommand(options) {
           }
           break;
         }
+        case "regenerate_with_model": {
+          const newInstructions = await he({
+            message: "Enter additional instructions for AI (or press Enter to skip):",
+            placeholder: "e.g., Keep all PDFs together, sort images by date"
+          });
+          if (pD(newInstructions)) {
+            break;
+          }
+          const pickedModel = await pickModel();
+          if (!pickedModel) {
+            break;
+          }
+          spinner.start(`Re-analyzing with ${pickedModel.provider}/${pickedModel.model}...`);
+          try {
+            proposal = await analyzeFiles({
+              files,
+              targetDir: targetPath,
+              instructions: newInstructions || undefined,
+              model: pickedModel
+            });
+            spinner.stop("Analysis complete");
+            displayAllProposals(proposal);
+          } catch (error) {
+            spinner.stop("Analysis failed");
+            M2.error(error.message);
+          }
+          break;
+        }
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "tidyf",
-	"version": "1.0.0",
+	"version": "1.0.1",
 	"description": "AI-powered file organizer using opencode.ai",
 	"type": "module",
 	"main": "dist/index.js",

package/src/commands/modelPicker.ts

@@ -0,0 +1,155 @@
+/**
+ * Interactive model picker for regenerate-with-model flow
+ */
+
+import * as p from "@clack/prompts";
+import { getAvailableModels } from "../lib/opencode.ts";
+import type { ModelSelection } from "../types/config.ts";
+
+/**
+ * Interactive model selection using OpenCode providers
+ */
+export async function pickModel(): Promise<ModelSelection | undefined> {
+	const s = p.spinner();
+	s.start("Fetching available models from OpenCode...");
+
+	let providers: any[] = [];
+	try {
+		const response = await getAvailableModels();
+		if (response.error) {
+			throw new Error("Failed to fetch models");
+		}
+		providers = response.data?.providers || [];
+		s.stop(`Fetched ${providers.length} providers`);
+	} catch (error: any) {
+		s.stop("Failed to fetch models");
+		p.log.error(error.message);
+		p.log.warn("Falling back to manual entry.");
+	}
+
+	let providerId: string;
+	let modelName: string;
+
+	if (providers.length > 0) {
+		const providerOptions = providers.map((prov) => ({
+			value: prov.id,
+			label: prov.name || prov.id,
+		}));
+
+		providerOptions.push({
+			value: "custom",
+			label: "Enter custom provider...",
+		});
+
+		const selectedProvider = await p.select({
+			message: "Select AI provider:",
+			options: providerOptions,
+		});
+
+		if (p.isCancel(selectedProvider)) {
+			return undefined;
+		}
+
+		if (selectedProvider === "custom") {
+			const customProv = await p.text({
+				message: "Enter provider ID:",
+				placeholder: "opencode",
+				validate: (value) => {
+					if (!value) return "Provider ID is required";
+				},
+			});
+			if (p.isCancel(customProv)) return undefined;
+			providerId = customProv;
+
+			const customModel = await p.text({
+				message: "Enter model ID:",
+				placeholder: "gpt-4o",
+				validate: (value) => {
+					if (!value) return "Model ID is required";
+				},
+			});
+			if (p.isCancel(customModel)) return undefined;
+			modelName = customModel;
+		} else {
+			providerId = selectedProvider as string;
+			const providerData = providers.find((p) => p.id === providerId);
+
+			if (!providerData || !providerData.models) {
+				p.log.warn(
+					`No models found for provider ${providerId}, please enter manually.`,
+				);
+				const customModel = await p.text({
+					message: "Enter model ID:",
+					placeholder: "gpt-4o",
+					validate: (value) => {
+						if (!value) return "Model ID is required";
+					},
+				});
+				if (p.isCancel(customModel)) return undefined;
+				modelName = customModel;
+			} else {
+				let modelIds: string[] = [];
+				if (Array.isArray(providerData.models)) {
+					modelIds = providerData.models;
+				} else if (typeof providerData.models === "object") {
+					modelIds = Object.keys(providerData.models);
+				}
+
+				if (modelIds.length === 0) {
+					p.log.warn(`No models found for provider ${providerId}`);
+					const customModel = await p.text({
+						message: "Enter model ID:",
+					});
+					if (p.isCancel(customModel)) return undefined;
+					modelName = customModel;
+				} else {
+					const modelOptions = modelIds.map((model: string) => ({
+						value: model,
+						label: model,
+					}));
+					modelOptions.push({
+						value: "custom",
+						label: "Enter custom model...",
+					});
+
+					const selectedModel = await p.select({
+						message: "Select model:",
+						options: modelOptions,
+					});
+
+					if (p.isCancel(selectedModel)) return undefined;
+
+					if (selectedModel === "custom") {
+						const customModel = await p.text({
+							message: "Enter model ID:",
+						});
+						if (p.isCancel(customModel)) return undefined;
+						modelName = customModel;
+					} else {
+						modelName = selectedModel as string;
+					}
+				}
+			}
+		}
+	} else {
+		const manualEntry = await p.text({
+			message: "Enter model (format: provider/model):",
+			placeholder: "opencode/gpt-4o",
+			validate: (value) => {
+				if (!value.includes("/")) {
+					return "Model must be in format: provider/model";
+				}
+			},
+		});
+
+		if (p.isCancel(manualEntry)) {
+			return undefined;
+		}
+
+		const parts = manualEntry.split("/");
+		providerId = parts[0];
+		modelName = parts.slice(1).join("/");
+	}
+
+	return { provider: providerId, model: modelName };
+}

package/src/commands/organize.ts

@@ -10,7 +10,6 @@
  */
 
 import * as p from "@clack/prompts";
-import { homedir } from "os";
 import { isAbsolute, resolve } from "path";
 import color from "picocolors";
 import {
@@ -27,12 +26,13 @@ import type {
   OrganizationProposal,
   OrganizeOptions,
 } from "../types/organizer.ts";
-import { fileExists, formatFileSize, moveFile } from "../utils/files.ts";
+import { formatFileSize, moveFile } from "../utils/files.ts";
 import {
   getCategoryIcon,
   getFileIcon,
   getStatusIndicator,
 } from "../utils/icons.ts";
+import { pickModel } from "./modelPicker.ts";
 
 /**
  * Display a single proposal
@@ -337,6 +337,11 @@ export async function organizeCommand(options: OrganizeOptions): Promise<void> {
             label: "Regenerate analysis",
             hint: "Ask AI to re-analyze with different instructions",
           },
+          {
+            value: "regenerate_with_model",
+            label: "Regenerate analysis (different model)",
+            hint: "Re-analyze using another provider/model",
+          },
           {
             value: "cancel",
             label: "Cancel",
@@ -387,6 +392,39 @@ export async function organizeCommand(options: OrganizeOptions): Promise<void> {
           }
           break;
         }
+
+        case "regenerate_with_model": {
+          const newInstructions = await p.text({
+            message:
+              "Enter additional instructions for AI (or press Enter to skip):",
+            placeholder: "e.g., Keep all PDFs together, sort images by date",
+          });
+
+          if (p.isCancel(newInstructions)) {
+            break;
+          }
+
+          const pickedModel = await pickModel();
+          if (!pickedModel) {
+            break;
+          }
+
+          spinner.start(`Re-analyzing with ${pickedModel.provider}/${pickedModel.model}...`);
+          try {
+            proposal = await analyzeFiles({
+              files,
+              targetDir: targetPath,
+              instructions: newInstructions || undefined,
+              model: pickedModel,
+            });
+            spinner.stop("Analysis complete");
+            displayAllProposals(proposal);
+          } catch (error: any) {
+            spinner.stop("Analysis failed");
+            p.log.error(error.message);
+          }
+          break;
+        }
       }
     }
   }