@anraktech/sync 0.10.0 → 0.11.0

package/dist/cli.js

@@ -619,7 +619,7 @@ function sleep(ms) {
 import { createInterface } from "readline/promises";
 import { stdin, stdout } from "process";
 import { homedir as homedir2, platform } from "os";
-import { resolve, join as join2, dirname as dirname2 } from "path";
+import { resolve, join as join2, dirname as dirname2, basename as basename4 } from "path";
 import { existsSync as existsSync2, readdirSync, statSync, readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath } from "url";
 import chalk2 from "chalk";
@@ -663,11 +663,57 @@ function normalizePath(folderPath) {
   return resolve(HOME, trimmed);
 }
 var TOOLS = [
+  {
+    type: "function",
+    function: {
+      name: "search_files",
+      description: "Search for files by name across one or more directories. Supports partial matching and glob patterns. Returns full paths, sizes, and whether files are syncable. Use this when user asks to find a specific file.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Search query \u2014 filename or partial name to match (case-insensitive). Examples: 'rental agreement', 'Black & White', '.pdf'"
+          },
+          searchPath: {
+            type: "string",
+            description: "Directory to search in. Defaults to home directory. Use absolute paths."
+          },
+          maxDepth: {
+            type: "number",
+            description: "Maximum directory depth to search. Default: 3. Increase for deeper searches."
+          }
+        },
+        required: ["query"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "upload_to_case",
+      description: "Upload a specific file to a specific legal case. Use when the user wants to upload a particular file to a particular case. Requires the full file path and case identifier (case number or name).",
+      parameters: {
+        type: "object",
+        properties: {
+          filePath: {
+            type: "string",
+            description: "Absolute path to the file to upload"
+          },
+          caseIdentifier: {
+            type: "string",
+            description: "Case number (e.g. 'CASE-001') or case name to upload to. Will fuzzy-match against available cases."
+          }
+        },
+        required: ["filePath", "caseIdentifier"]
+      }
+    }
+  },
   {
     type: "function",
     function: {
       name: "browse_folder",
-      description: "List files and subfolders in a local directory. Shows file names, sizes, types, and whether they are syncable. Use FIRST when user wants to see what's in a folder before syncing.",
+      description: "List files and subfolders in a local directory. Shows file names, sizes, types, and whether they are syncable. Use when user wants to see what's in a folder. For finding a specific file, use search_files instead.",
       parameters: {
         type: "object",
         properties: {
@@ -679,6 +725,10 @@ var TOOLS = [
             type: "string",
             enum: ["all", "syncable", "folders"],
             description: "Filter: 'all' shows everything, 'syncable' shows only supported file types (PDF, DOCX, etc.), 'folders' shows only subfolders. Default: all"
+          },
+          nameFilter: {
+            type: "string",
+            description: "Optional: filter items by name (case-insensitive substring match). Use to narrow down large folders."
           }
         },
         required: ["folderPath"]
@@ -689,7 +739,7 @@ var TOOLS = [
     type: "function",
     function: {
       name: "scan_folder",
-      description: "Sync all supported files from a local folder to a matching legal case. Use when user explicitly asks to sync, upload, or push files. If unsure what's in the folder, use browse_folder first.",
+      description: "Sync ALL supported files from a local folder to a matching legal case. Use ONLY when user explicitly asks to sync an entire folder. For uploading a single file, use upload_to_case instead.",
       parameters: {
         type: "object",
         properties: {
@@ -761,8 +811,10 @@ Rules:
   "desktop" \u2192 ${join2(HOME, "Desktop")}
   "documents" \u2192 ${join2(HOME, "Documents")}
   "~/SomeFolder" \u2192 ${HOME}/SomeFolder
-- When user says "look at" or "check" a folder, use browse_folder FIRST to show what's there.
-- When user says "sync" or "upload", use scan_folder to actually sync.
+- FINDING FILES: When user asks to find or locate a specific file, ALWAYS use search_files. NEVER browse a folder hoping to find it.
+- UPLOADING: When user wants to upload a specific file to a case, use upload_to_case (NOT scan_folder). scan_folder uploads EVERYTHING.
+- When user says "look at" or "check" a folder, use browse_folder to show what's there.
+- When user says "sync all" or "sync this folder", use scan_folder.
 - When browsing, highlight which files are syncable (PDF, DOCX, XLSX, etc.) vs not.
 - Present file lists in a clean table/list format with names and sizes.
 - Call tools to perform actions. Summarize results naturally after.
@@ -771,6 +823,117 @@ Rules:
 }
 async function executeTool(name, args, ctx) {
   switch (name) {
+    case "search_files": {
+      let searchDir2 = function(dir, depth) {
+        if (depth > maxDepth || results.length >= 20) return;
+        let entries;
+        try {
+          entries = readdirSync(dir);
+        } catch {
+          return;
+        }
+        for (const entry of entries) {
+          if (results.length >= 20) break;
+          if (isIgnoredFile(entry)) continue;
+          const fullPath = join2(dir, entry);
+          let st;
+          try {
+            st = statSync(fullPath);
+          } catch {
+            continue;
+          }
+          if (st.isDirectory()) {
+            searchDir2(fullPath, depth + 1);
+          } else if (st.isFile() && entry.toLowerCase().includes(queryLower)) {
+            const sizeKB = Math.round(st.size / 1024);
+            const size = sizeKB > 1024 ? `${(sizeKB / 1024).toFixed(1)} MB` : `${sizeKB} KB`;
+            results.push({
+              name: entry,
+              path: fullPath,
+              size,
+              syncable: isSupportedFile(entry)
+            });
+          }
+        }
+      };
+      var searchDir = searchDir2;
+      const query = (args.query || "").trim();
+      if (!query) return JSON.stringify({ error: "Missing search query" });
+      const rawSearch = args.searchPath || HOME;
+      const searchPath = normalizePath(rawSearch);
+      const maxDepth = Math.min(args.maxDepth || 3, 6);
+      if (!existsSync2(searchPath) || !statSync(searchPath).isDirectory()) {
+        return JSON.stringify({ error: `Search path not found: ${searchPath}` });
+      }
+      const queryLower = query.toLowerCase();
+      const results = [];
+      searchDir2(searchPath, 0);
+      return JSON.stringify({
+        query,
+        searchPath,
+        found: results.length,
+        maxResults: 20,
+        results
+      });
+    }
+    case "upload_to_case": {
+      const rawPath = args.filePath;
+      const caseId = args.caseIdentifier;
+      if (!rawPath) return JSON.stringify({ error: "Missing filePath" });
+      if (!caseId) return JSON.stringify({ error: "Missing caseIdentifier" });
+      const filePath = normalizePath(rawPath);
+      if (!existsSync2(filePath)) {
+        return JSON.stringify({ error: `File not found: ${filePath}` });
+      }
+      const fileStat = statSync(filePath);
+      if (!fileStat.isFile()) {
+        return JSON.stringify({ error: `Not a file: ${filePath}` });
+      }
+      if (fileStat.size > 50 * 1024 * 1024) {
+        return JSON.stringify({ error: `File exceeds 50MB limit (${(fileStat.size / 1024 / 1024).toFixed(1)}MB)` });
+      }
+      if (!isSupportedFile(basename4(filePath))) {
+        return JSON.stringify({ error: `Unsupported file type: ${basename4(filePath)}. Supported: PDF, DOCX, XLSX, PPTX, TXT, images` });
+      }
+      await ctx.refreshCases();
+      const cases = ctx.getCases();
+      const searchLower = caseId.toLowerCase();
+      let matchedCase = cases.find(
+        (c) => c.caseNumber.toLowerCase() === searchLower || c.caseName.toLowerCase() === searchLower
+      );
+      if (!matchedCase) {
+        matchedCase = cases.find(
+          (c) => c.caseNumber.toLowerCase().includes(searchLower) || c.caseName.toLowerCase().includes(searchLower)
+        );
+      }
+      if (!matchedCase) {
+        return JSON.stringify({
+          error: `No case matching "${caseId}". Available cases: ${cases.map((c) => `${c.caseNumber} (${c.caseName})`).join(", ")}`
+        });
+      }
+      try {
+        log.file("uploading", `${basename4(filePath)} -> ${matchedCase.caseName}`);
+        const result = await uploadFile(ctx.config, matchedCase.id, filePath);
+        if (result.success && result.linkedDocumentIds.length > 0) {
+          const hash = await hashFile(filePath);
+          markSynced(filePath, hash, fileStat.size, matchedCase.id, result.linkedDocumentIds[0]);
+          log.success(`Uploaded ${basename4(filePath)} to ${matchedCase.caseName}`);
+          return JSON.stringify({
+            success: true,
+            filename: basename4(filePath),
+            caseName: matchedCase.caseName,
+            caseNumber: matchedCase.caseNumber,
+            documentId: result.linkedDocumentIds[0]
+          });
+        } else {
+          return JSON.stringify({
+            error: `Upload completed but no document was linked. The file may be a duplicate.`
+          });
+        }
+      } catch (err) {
+        return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
+      }
+    }
     case "browse_folder": {
       const rawPath = args.folderPath;
       if (!rawPath) return JSON.stringify({ error: "Missing folderPath" });
@@ -787,10 +950,12 @@ async function executeTool(name, args, ctx) {
         return JSON.stringify({ error: `Cannot access: ${folderPath}` });
       }
       const filter = args.filter || "all";
+      const nameFilter = (args.nameFilter || "").toLowerCase();
       const entries = readdirSync(folderPath);
       const items = [];
       for (const entry of entries) {
         if (isIgnoredFile(entry)) continue;
+        if (nameFilter && !entry.toLowerCase().includes(nameFilter)) continue;
         const fullPath = join2(folderPath, entry);
         let st;
         try {
@@ -814,9 +979,9 @@ async function executeTool(name, args, ctx) {
       return JSON.stringify({
         folder: folderPath,
         totalItems: items.length,
-        items: items.slice(0, 50),
-        // Cap at 50 to avoid token explosion
-        truncated: items.length > 50
+        items: items.slice(0, 100),
+        // Increased from 50 to 100
+        truncated: items.length > 100
       });
     }
     case "scan_folder": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anraktech/sync",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "AnrakLegal desktop file sync agent — watches local folders and syncs to case management",
   "type": "module",
   "bin": {