@anraktech/sync 0.13.1 → 0.15.0

package/dist/cli.js

@@ -4,14 +4,15 @@
 import { Command } from "commander";
 import { createInterface as createInterface2 } from "readline/promises";
 import { stdin as stdin2, stdout as stdout2 } from "process";
-import { existsSync as existsSync4, statSync as statSync3 } from "fs";
-import { resolve as resolve3 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve4 } from "path";
+import { homedir as homedir3 } from "os";
 import chalk4 from "chalk";
 
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
+import { join, resolve } from "path";
 
 // src/logger.ts
 import chalk from "chalk";
@@ -31,11 +32,29 @@ var log = {
 var CONFIG_DIR = join(homedir(), ".anrak-sync");
 var CONFIG_FILE = join(CONFIG_DIR, "config.json");
 var CACHE_FILE = join(CONFIG_DIR, "cache.json");
+var HOME = homedir();
+var SHORTCUTS = {
+  downloads: join(HOME, "Downloads"),
+  download: join(HOME, "Downloads"),
+  desktop: join(HOME, "Desktop"),
+  documents: join(HOME, "Documents"),
+  document: join(HOME, "Documents")
+};
+function normalizePath(p) {
+  if (!p) return p;
+  if (p.startsWith("~/") || p === "~") return resolve(p.replace(/^~/, HOME));
+  const lower = p.toLowerCase().replace(/^\//, "");
+  if (SHORTCUTS[lower]) return SHORTCUTS[lower];
+  if (p.startsWith("/") && !existsSync(p) && SHORTCUTS[p.slice(1).toLowerCase()]) {
+    return SHORTCUTS[p.slice(1).toLowerCase()];
+  }
+  return p;
+}
 function getWatchFolders(config) {
   const folders = /* @__PURE__ */ new Set();
-  if (config.watchFolder) folders.add(config.watchFolder);
+  if (config.watchFolder) folders.add(normalizePath(config.watchFolder));
   if (config.watchFolders) {
-    for (const f of config.watchFolders) folders.add(f);
+    for (const f of config.watchFolders) folders.add(normalizePath(f));
   }
   return [...folders];
 }
@@ -115,7 +134,7 @@ function openBrowser(url) {
   exec(`${cmd} "${url}"`);
 }
 function findFreePort() {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const srv = createServer();
     srv.listen(0, () => {
       const addr = srv.address();
@@ -125,14 +144,14 @@ function findFreePort() {
         return;
       }
       const port = addr.port;
-      srv.close(() => resolve4(port));
+      srv.close(() => resolve5(port));
     });
   });
 }
 async function browserLogin(apiUrl) {
   const port = await findFreePort();
   return new Promise(
-    (resolve4, reject) => {
+    (resolve5, reject) => {
       let server;
       const timeout = setTimeout(() => {
         server?.close();
@@ -179,7 +198,7 @@ async function browserLogin(apiUrl) {
           const tokens = await resp.json();
           clearTimeout(timeout);
           server.close();
-          resolve4(tokens);
+          resolve5(tokens);
         } catch (err) {
           clearTimeout(timeout);
           server.close();
@@ -367,11 +386,11 @@ function persist() {
   if (cache) saveCache(cache);
 }
 function hashFile(filePath) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const hash = createHash("sha256");
     const stream = createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("end", () => resolve4(hash.digest("hex")));
+    stream.on("end", () => resolve5(hash.digest("hex")));
     stream.on("error", reject);
   });
 }
@@ -446,7 +465,7 @@ function resetCache() {
 // src/watcher.ts
 import { watch } from "chokidar";
 import { readdirSync as readdirSync2, statSync as statSync2, existsSync as existsSync3 } from "fs";
-import { join as join3, relative as relative2, basename as basename5, resolve as resolve2 } from "path";
+import { join as join3, relative as relative2, basename as basename5, resolve as resolve3 } from "path";
 
 // src/uploader.ts
 import { stat as stat2 } from "fs/promises";
@@ -454,6 +473,40 @@ import { basename as basename3, dirname, relative } from "path";
 
 // src/mapper.ts
 import { basename as basename2 } from "path";
+
+// src/events.ts
+var pendingFiles = [];
+var recentMappings = [];
+var MAX_RECENT = 20;
+function addRecentMapping(msg) {
+  recentMappings.push(msg);
+  if (recentMappings.length > MAX_RECENT) {
+    recentMappings.shift();
+  }
+}
+function addPendingFile(file) {
+  if (!pendingFiles.some((f) => f.filePath === file.filePath)) {
+    pendingFiles.push(file);
+  }
+}
+function removePendingFile(filePath) {
+  const idx = pendingFiles.findIndex((f) => f.filePath === filePath);
+  if (idx >= 0) {
+    return pendingFiles.splice(idx, 1)[0];
+  }
+  return void 0;
+}
+function removePendingByFolder(folderName) {
+  const removed = [];
+  for (let i = pendingFiles.length - 1; i >= 0; i--) {
+    if (pendingFiles[i].folderName === folderName) {
+      removed.push(pendingFiles.splice(i, 1)[0]);
+    }
+  }
+  return removed;
+}
+
+// src/mapper.ts
 function normalize(s) {
   return s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -506,7 +559,7 @@ function deriveCaseInfo(folderName) {
     caseName: sanitized
   };
 }
-async function resolveFolder(config, folderPath, cases) {
+async function resolveFolder(config, folderPath, cases, options) {
   const folderName = basename2(folderPath);
   const cached = getFolderMapping(folderName);
   if (cached) {
@@ -522,6 +575,7 @@ async function resolveFolder(config, folderPath, cases) {
   if (match) {
     log.success(`Mapped "${folderName}" -> ${match.caseNumber} (${match.caseName})`);
     setFolderMapping(folderName, match.id, match.caseName, match.caseNumber);
+    addRecentMapping(`Mapped "${folderName}" \u2192 ${match.caseNumber} (${match.caseName})`);
     return {
       caseId: match.id,
       caseName: match.caseName,
@@ -529,12 +583,63 @@ async function resolveFolder(config, folderPath, cases) {
       created: false
     };
   }
+  if (options?.smartMapper && allCases.length > 0) {
+    try {
+      const smartResult = await options.smartMapper(
+        folderName,
+        options.fileName || folderName,
+        allCases
+      );
+      if (smartResult) {
+        if (smartResult.confidence === "high") {
+          log.success(`AI mapped "${folderName}" \u2192 ${smartResult.caseNumber} (${smartResult.reason})`);
+          setFolderMapping(folderName, smartResult.caseId, smartResult.caseName, smartResult.caseNumber);
+          addRecentMapping(
+            `AI mapped "${options.fileName || folderName}" \u2192 ${smartResult.caseNumber} (${smartResult.caseName})`
+          );
+          return {
+            caseId: smartResult.caseId,
+            caseName: smartResult.caseName,
+            caseNumber: smartResult.caseNumber,
+            created: false
+          };
+        } else {
+          log.info(
+            `AI unsure about "${folderName}" \u2014 suggests ${smartResult.caseNumber} (${smartResult.reason})`
+          );
+          addPendingFile({
+            filePath: "",
+            // Set by uploader
+            folderName,
+            suggestion: {
+              caseName: smartResult.caseName,
+              caseNumber: smartResult.caseNumber,
+              reason: smartResult.reason
+            },
+            addedAt: Date.now()
+          });
+          addRecentMapping(
+            `Unsure: "${options.fileName || folderName}" in "${folderName}" \u2014 AI suggests ${smartResult.caseNumber} but needs confirmation`
+          );
+          return {
+            caseId: "",
+            caseName: "",
+            caseNumber: "",
+            created: false,
+            needsInput: true
+          };
+        }
+      }
+    } catch {
+    }
+  }
   const { caseNumber, caseName } = deriveCaseInfo(folderName);
   log.info(`No match for "${folderName}" \u2014 creating case ${caseNumber}`);
   try {
     const newCase = await createCase(config, caseNumber, caseName);
     setFolderMapping(folderName, newCase.id, newCase.caseName, newCase.caseNumber);
     log.success(`Created case ${newCase.caseNumber} (${newCase.caseName})`);
+    addRecentMapping(`Created new case "${newCase.caseNumber}" for folder "${folderName}"`);
     return {
       caseId: newCase.id,
       caseName: newCase.caseName,
@@ -583,7 +688,7 @@ async function enqueue(filePath, watchFolder) {
   queue.push({ filePath, folderPath, retries: 0 });
   log.file("queued", relative(watchFolder, filePath));
 }
-async function processQueue(config, cases) {
+async function processQueue(config, cases, options) {
   if (processing) return { uploaded: 0, failed: 0 };
   processing = true;
   let uploaded = 0;
@@ -596,11 +701,29 @@ async function processQueue(config, cases) {
       await sleep(RATE_LIMIT_INTERVAL_MS - elapsed);
     }
     try {
-      const { caseId, caseName } = await resolveFolder(
+      const resolved = await resolveFolder(
         config,
         item.folderPath,
-        cases
+        cases,
+        { smartMapper: options?.smartMapper, fileName: filename }
       );
+      if (resolved.needsInput) {
+        const pending = pendingFiles.find(
+          (p) => p.folderName === basename3(item.folderPath) && !p.filePath
+        );
+        if (pending) {
+          pending.filePath = item.filePath;
+        } else {
+          addPendingFile({
+            filePath: item.filePath,
+            folderName: basename3(item.folderPath),
+            addedAt: Date.now()
+          });
+        }
+        log.info(`Waiting for mapping: ${filename}`);
+        continue;
+      }
+      const { caseId, caseName } = resolved;
       const hash = await hashFile(item.filePath);
       const s = await stat2(item.filePath);
       markPending(item.filePath, hash, s.size, caseId);
@@ -649,7 +772,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, basename as basename4 } from "path";
+import { resolve as resolve2, 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,21 +786,21 @@ var PKG_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var HOME = homedir2();
+var HOME2 = homedir2();
 var IS_MAC = platform() === "darwin";
 var FOLDER_SHORTCUTS = {
-  downloads: join2(HOME, "Downloads"),
-  download: join2(HOME, "Downloads"),
-  desktop: join2(HOME, "Desktop"),
-  documents: join2(HOME, "Documents"),
-  document: join2(HOME, "Documents"),
-  home: HOME,
-  "~": HOME
+  downloads: join2(HOME2, "Downloads"),
+  download: join2(HOME2, "Downloads"),
+  desktop: join2(HOME2, "Desktop"),
+  documents: join2(HOME2, "Documents"),
+  document: join2(HOME2, "Documents"),
+  home: HOME2,
+  "~": HOME2
 };
-function normalizePath(folderPath) {
+function normalizePath2(folderPath) {
   const trimmed = folderPath.trim();
   if (trimmed.startsWith("~/") || trimmed === "~") {
-    return resolve(trimmed.replace(/^~/, HOME));
+    return resolve2(trimmed.replace(/^~/, HOME2));
   }
   const lower = trimmed.toLowerCase();
   if (FOLDER_SHORTCUTS[lower]) {
@@ -688,9 +811,9 @@ function normalizePath(folderPath) {
     return FOLDER_SHORTCUTS[withoutSlash];
   }
   if (trimmed.startsWith("/") || /^[A-Z]:\\/i.test(trimmed)) {
-    return resolve(trimmed);
+    return resolve2(trimmed);
   }
-  return resolve(HOME, trimmed);
+  return resolve2(HOME2, trimmed);
 }
 var TOOLS = [
   {
@@ -845,28 +968,42 @@ var TOOLS = [
     }
   }
 ];
-function buildSystemPrompt(config) {
+function buildSystemPrompt(config, onboarding) {
   const folders = getWatchFolders(config);
   const folderList = folders.map((f) => `  - ${f}`).join("\n");
+  const onboardingBlock = onboarding ? `
+ONBOARDING MODE \u2014 This is the user's first time using AnrakLegal Sync. You just finished setup.
+Your FIRST response must:
+1. Welcome them warmly (1 line).
+2. Ask which folders on their computer contain legal files they'd like to sync. Give examples like:
+   - Downloads (${join2(HOME2, "Downloads")}) \u2014 where they download court orders, filings
+   - Desktop (${join2(HOME2, "Desktop")}) \u2014 quick-access files
+   - Documents (${join2(HOME2, "Documents")}) \u2014 organized case folders
+   - A custom folder path
+3. Tell them they can name multiple folders at once, e.g. "downloads and desktop"
+4. After the user responds, use manage_watch_folders to add each folder they mention.
+5. Once folders are set, confirm the setup and let them know you're now watching for new files.
+Keep it conversational and simple \u2014 they are lawyers, not developers.
+` : "";
   return `You are AnrakLegal Sync, a terminal assistant that helps lawyers sync local files to their case management system.
 
 Watch folders:
 ${folderList}
 Server: ${config.apiUrl}
-Home directory: ${HOME}
+Home directory: ${HOME2}
 Platform: ${IS_MAC ? "macOS" : platform()}
 
 You can browse local folders, scan & sync files, list cases, show sync status, manage watch folders, and more.
-
+${onboardingBlock}
 Rules:
 - Be concise. This is a terminal \u2014 1-3 lines unless showing a list.
 - Do NOT use markdown. Plain text only.
 - WATCH FOLDERS: When user asks to "watch", "add", or "also sync" a folder, use manage_watch_folders with action "add". When they say "stop watching" or "remove" a folder, use action "remove".
 - IMPORTANT: When user mentions a folder like "downloads" or "desktop", ALWAYS use the full absolute path. Examples:
-  "downloads" or "my downloads" \u2192 ${join2(HOME, "Downloads")}
-  "desktop" \u2192 ${join2(HOME, "Desktop")}
-  "documents" \u2192 ${join2(HOME, "Documents")}
-  "~/SomeFolder" \u2192 ${HOME}/SomeFolder
+  "downloads" or "my downloads" \u2192 ${join2(HOME2, "Downloads")}
+  "desktop" \u2192 ${join2(HOME2, "Desktop")}
+  "documents" \u2192 ${join2(HOME2, "Documents")}
+  "~/SomeFolder" \u2192 ${HOME2}/SomeFolder
 - 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.
@@ -875,7 +1012,19 @@ Rules:
 - Present file lists in a clean table/list format with names and sizes.
 - Call tools to perform actions. Summarize results naturally after.
 - If a tool returns an error, report it clearly to the user.
-- Do NOT use thinking tags or reasoning tags in your output.`;
+- PENDING MAPPINGS: When there are files waiting for case assignment, proactively ask the user which case to map them to. Use upload_to_case to upload once the user confirms.
+- Do NOT use thinking tags or reasoning tags in your output.
+${pendingFiles.length > 0 ? `
+FILES WAITING FOR MAPPING (ask user which case):
+${pendingFiles.map((f) => {
+    const name = basename4(f.filePath || "unknown");
+    const sug = f.suggestion ? ` \u2014 AI suggests: ${f.suggestion.caseName} (${f.suggestion.reason})` : "";
+    return `- ${name} in folder "${f.folderName}"${sug}`;
+  }).join("\n")}
+` : ""}${recentMappings.length > 0 ? `
+Recent mapping activity:
+${recentMappings.slice(-5).map((m) => `- ${m}`).join("\n")}
+` : ""}`;
 }
 async function executeTool(name, args, ctx) {
   switch (name) {
@@ -915,8 +1064,8 @@ async function executeTool(name, args, ctx) {
       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 rawSearch = args.searchPath || HOME2;
+      const searchPath = normalizePath2(rawSearch);
       const maxDepth = Math.min(args.maxDepth || 3, 6);
       if (!existsSync2(searchPath) || !statSync(searchPath).isDirectory()) {
         return JSON.stringify({ error: `Search path not found: ${searchPath}` });
@@ -937,7 +1086,7 @@ async function executeTool(name, args, ctx) {
       const caseId = args.caseIdentifier;
       if (!rawPath) return JSON.stringify({ error: "Missing filePath" });
       if (!caseId) return JSON.stringify({ error: "Missing caseIdentifier" });
-      const filePath = normalizePath(rawPath);
+      const filePath = normalizePath2(rawPath);
       if (!existsSync2(filePath)) {
         return JSON.stringify({ error: `File not found: ${filePath}` });
       }
@@ -974,6 +1123,28 @@ async function executeTool(name, args, ctx) {
           const hash = await hashFile(filePath);
           markSynced(filePath, hash, fileStat.size, matchedCase.id, result.linkedDocumentIds[0]);
           log.success(`Uploaded ${basename4(filePath)} to ${matchedCase.caseName}`);
+          removePendingFile(filePath);
+          const parentFolder = dirname2(filePath);
+          const folderName = basename4(parentFolder);
+          if (folderName && matchedCase) {
+            setFolderMapping(folderName, matchedCase.id, matchedCase.caseName, matchedCase.caseNumber);
+            const sameFolderPending = removePendingByFolder(folderName);
+            for (const pf of sameFolderPending) {
+              if (pf.filePath && pf.filePath !== filePath) {
+                try {
+                  const pfResult = await uploadFile(ctx.config, matchedCase.id, pf.filePath);
+                  if (pfResult.success && pfResult.linkedDocumentIds.length > 0) {
+                    const pfHash = await hashFile(pf.filePath);
+                    const pfStat = statSync(pf.filePath);
+                    markSynced(pf.filePath, pfHash, pfStat.size, matchedCase.id, pfResult.linkedDocumentIds[0]);
+                    log.success(`Also uploaded ${basename4(pf.filePath)} to ${matchedCase.caseName}`);
+                  }
+                } catch {
+                  log.warn(`Failed to upload pending file: ${basename4(pf.filePath)}`);
+                }
+              }
+            }
+          }
           return JSON.stringify({
             success: true,
             filename: basename4(filePath),
@@ -993,7 +1164,7 @@ async function executeTool(name, args, ctx) {
     case "browse_folder": {
       const rawPath = args.folderPath;
       if (!rawPath) return JSON.stringify({ error: "Missing folderPath" });
-      const folderPath = normalizePath(rawPath);
+      const folderPath = normalizePath2(rawPath);
       if (!existsSync2(folderPath)) {
         return JSON.stringify({ error: `Folder not found: ${folderPath}` });
       }
@@ -1043,7 +1214,7 @@ async function executeTool(name, args, ctx) {
     case "scan_folder": {
       const rawPath = args.folderPath;
       if (!rawPath) return JSON.stringify({ error: "Missing folderPath" });
-      const folderPath = normalizePath(rawPath);
+      const folderPath = normalizePath2(rawPath);
       try {
         await ctx.scanFolder(folderPath);
         const stats = getStats();
@@ -1115,7 +1286,7 @@ async function executeTool(name, args, ctx) {
       }
       if (action === "add") {
         if (!rawFolder) return JSON.stringify({ error: "Missing folderPath" });
-        const folderPath = normalizePath(rawFolder);
+        const folderPath = normalizePath2(rawFolder);
         if (!ctx.addWatchFolder) {
           return JSON.stringify({ error: "Watch folder management not available" });
         }
@@ -1127,7 +1298,7 @@ async function executeTool(name, args, ctx) {
       }
       if (action === "remove") {
         if (!rawFolder) return JSON.stringify({ error: "Missing folderPath" });
-        const folderPath = normalizePath(rawFolder);
+        const folderPath = normalizePath2(rawFolder);
         if (!ctx.removeWatchFolder) {
           return JSON.stringify({ error: "Watch folder management not available" });
         }
@@ -1238,13 +1409,13 @@ async function agentTurn(messages, ctx) {
 }
 function startAIAgent(ctx) {
   const history = [
-    { role: "system", content: buildSystemPrompt(ctx.config) }
+    { role: "system", content: buildSystemPrompt(ctx.config, ctx.onboarding) }
   ];
   const rl = createInterface({ input: stdin, output: stdout });
   const W = Math.min(process.stdout.columns || 60, 60);
   const allFolders = getWatchFolders(ctx.config);
   const folderDisplays = allFolders.map(
-    (f) => f.startsWith(HOME) ? "~" + f.slice(HOME.length) : f
+    (f) => f.startsWith(HOME2) ? "~" + f.slice(HOME2.length) : f
   );
   const stats = ctx.bootStats;
   const pad = (s, len) => {
@@ -1290,7 +1461,11 @@ function startAIAgent(ctx) {
     console.log(row(`${chalk2.dim("Status")}  ${statusLine}`));
   }
   console.log(empty);
-  console.log(row(chalk2.dim("Type naturally, or press / for commands.")));
+  if (ctx.onboarding) {
+    console.log(row(chalk2.dim("First-time setup \u2014 the AI will guide you.")));
+  } else {
+    console.log(row(chalk2.dim("Type naturally, or press / for commands.")));
+  }
   console.log(empty);
   console.log(bot);
   console.log("");
@@ -1361,7 +1536,7 @@ function startAIAgent(ctx) {
           console.log(chalk2.dim("  " + "\u2500".repeat(40)));
           for (let i = 0; i < folders.length; i++) {
             const f = folders[i];
-            const display = f.startsWith(HOME) ? "~" + f.slice(HOME.length) : f;
+            const display = f.startsWith(HOME2) ? "~" + f.slice(HOME2.length) : f;
             const tag = f === ctx.config.watchFolder ? chalk2.cyan(" (primary)") : "";
             console.log(`  ${chalk2.dim(`${i + 1}.`)} ${display}${tag}`);
           }
@@ -1379,14 +1554,14 @@ function startAIAgent(ctx) {
             console.log(chalk2.red("  Usage: /folder add <path>"));
             return;
           }
-          const absPath = normalizePath(folderArg);
+          const absPath = normalizePath2(folderArg);
           if (!ctx.addWatchFolder) {
             console.log(chalk2.red("  Watch folder management not available."));
             return;
           }
           const result = await ctx.addWatchFolder(absPath);
           if (result.added) {
-            const display = (result.path || absPath).startsWith(HOME) ? "~" + (result.path || absPath).slice(HOME.length) : result.path || absPath;
+            const display = (result.path || absPath).startsWith(HOME2) ? "~" + (result.path || absPath).slice(HOME2.length) : result.path || absPath;
             console.log(chalk2.green(`  Added: ${display}`));
           } else {
             console.log(chalk2.yellow(`  ${result.error || "Could not add folder"}`));
@@ -1396,14 +1571,14 @@ function startAIAgent(ctx) {
             console.log(chalk2.red("  Usage: /folder remove <path>"));
             return;
           }
-          const absPath = normalizePath(folderArg);
+          const absPath = normalizePath2(folderArg);
           if (!ctx.removeWatchFolder) {
             console.log(chalk2.red("  Watch folder management not available."));
             return;
           }
           const result = ctx.removeWatchFolder(absPath);
           if (result.removed) {
-            const display = absPath.startsWith(HOME) ? "~" + absPath.slice(HOME.length) : absPath;
+            const display = absPath.startsWith(HOME2) ? "~" + absPath.slice(HOME2.length) : absPath;
             console.log(chalk2.green(`  Removed: ${display}`));
           } else {
             console.log(chalk2.yellow(`  ${result.error || "Could not remove folder"}`));
@@ -1413,14 +1588,14 @@ function startAIAgent(ctx) {
             console.log(chalk2.red("  Usage: /folder set <path>"));
             return;
           }
-          const absPath = normalizePath(folderArg);
+          const absPath = normalizePath2(folderArg);
           if (!existsSync2(absPath) || !statSync(absPath).isDirectory()) {
             console.log(chalk2.red(`  Not a valid directory: ${absPath}`));
             return;
           }
           ctx.config.watchFolder = absPath;
           saveConfig(ctx.config);
-          const display = absPath.startsWith(HOME) ? "~" + absPath.slice(HOME.length) : absPath;
+          const display = absPath.startsWith(HOME2) ? "~" + absPath.slice(HOME2.length) : absPath;
           console.log(chalk2.green(`  Primary folder set to: ${display}`));
         } else {
           console.log(chalk2.dim("  Usage: /folder [list|add|remove|set] <path>"));
@@ -1506,8 +1681,41 @@ function startAIAgent(ctx) {
     }
   };
   let currentSlashArgs = "";
+  let lastPendingCount = 0;
+  let onboardingDone = !ctx.onboarding;
   async function promptLoop() {
+    if (!onboardingDone) {
+      onboardingDone = true;
+      history.push({ role: "user", content: "Hi, I just installed AnrakLegal Sync. Help me set up my watch folders." });
+      try {
+        const response = await agentTurn([...history], ctx);
+        if (response) {
+          history.push({ role: "assistant", content: response });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(chalk2.red(`  Error: ${msg}`));
+      }
+      console.log("");
+    }
     while (true) {
+      if (pendingFiles.length > 0 && pendingFiles.length !== lastPendingCount) {
+        lastPendingCount = pendingFiles.length;
+        console.log("");
+        console.log(chalk2.yellow(`  ${pendingFiles.length} file(s) need case mapping:`));
+        for (const f of pendingFiles) {
+          const name = basename4(f.filePath || "unknown");
+          if (f.suggestion) {
+            console.log(
+              `  ${chalk2.cyan(name)} ${chalk2.dim("in")} ${f.folderName} ${chalk2.dim("\u2014 AI suggests:")} ${chalk2.green(f.suggestion.caseName)}`
+            );
+          } else {
+            console.log(`  ${chalk2.cyan(name)} ${chalk2.dim("in")} ${f.folderName} ${chalk2.dim("\u2014 no match found")}`);
+          }
+        }
+        console.log(chalk2.dim("  Tell me which case, or say 'yes' to accept suggestions."));
+        console.log("");
+      }
       let input;
       try {
         input = await rl.question(PROMPT);
@@ -1558,6 +1766,7 @@ function startAIAgent(ctx) {
       while (history.length > 21) {
         history.splice(1, 1);
       }
+      history[0] = { role: "system", content: buildSystemPrompt(ctx.config, false) };
       try {
         const response = await agentTurn([...history], ctx);
         if (response) {
@@ -1573,6 +1782,92 @@ function startAIAgent(ctx) {
   void promptLoop();
 }
 
+// src/smart-mapper.ts
+async function smartMapFolder(config, folderName, fileName, cases) {
+  if (cases.length === 0) return null;
+  let token;
+  try {
+    token = await getAccessToken(config);
+  } catch {
+    return null;
+  }
+  const caseList = cases.map((c, i) => `${i + 1}. ${c.caseNumber}: ${c.caseName}`).join("\n");
+  const messages = [
+    {
+      role: "system",
+      content: "You are a legal file organizer. Match files to legal cases. Respond ONLY with a JSON object. No markdown, no explanation outside JSON."
+    },
+    {
+      role: "user",
+      content: `Match this file to one of the cases below.
+
+File: ${fileName}
+Folder: ${folderName}
+
+Cases:
+${caseList}
+
+Respond with ONLY valid JSON:
+If a case matches: {"caseIndex": <number 1-${cases.length}>, "confidence": "high" or "low", "reason": "<10 words max>"}
+If no case matches: {"caseIndex": null, "confidence": "none", "reason": "<why>"}`
+    }
+  ];
+  try {
+    const response = await fetch(`${config.apiUrl}/api/sync/chat`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ messages }),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!response.ok) return null;
+    let text = "";
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, { stream: true });
+      for (const line of chunk.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data: ")) continue;
+        const data = trimmed.slice(6);
+        if (data === "[DONE]") continue;
+        try {
+          const parsed = JSON.parse(data);
+          const content = parsed.choices?.[0]?.delta?.content;
+          if (content) text += content;
+        } catch {
+        }
+      }
+    }
+    text = text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+    const jsonMatch = text.match(/\{[\s\S]*?\}/);
+    if (!jsonMatch) return null;
+    const result = JSON.parse(jsonMatch[0]);
+    if (result.caseIndex == null || result.confidence === "none") {
+      return null;
+    }
+    const idx = result.caseIndex - 1;
+    if (idx < 0 || idx >= cases.length) return null;
+    const matched = cases[idx];
+    return {
+      caseId: matched.id,
+      caseName: matched.caseName,
+      caseNumber: matched.caseNumber,
+      confidence: result.confidence === "high" ? "high" : "low",
+      reason: result.reason || ""
+    };
+  } catch (err) {
+    log.debug(
+      `Smart mapper error: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
+
 // src/watcher.ts
 async function scanFolder(config) {
   const folders = getWatchFolders(config);
@@ -1625,7 +1920,7 @@ async function pushSync(config) {
   );
 }
 async function scanExternalFolder(config, folderPath, cases) {
-  const absPath = resolve2(folderPath);
+  const absPath = resolve3(folderPath);
   if (!existsSync3(absPath)) {
     log.error(`Folder not found: ${absPath}`);
     return;
@@ -1671,12 +1966,13 @@ async function scanExternalFolder(config, folderPath, cases) {
     log.success("Everything up to date");
   }
 }
-async function startWatching(config) {
+async function startWatching(config, opts) {
   const folders = getWatchFolders(config);
+  const smartMapper = async (folderName, fileName, caseList) => smartMapFolder(config, folderName, fileName, caseList);
   let cases = await listCases(config);
   const { scanned, queued } = await scanFolder(config);
   if (queued > 0) {
-    const result = await processQueue(config, cases);
+    const result = await processQueue(config, cases, { smartMapper });
     if (result.failed > 0) {
       log.warn(`Initial sync: ${result.uploaded} uploaded, ${result.failed} failed`);
     }
@@ -1693,7 +1989,7 @@ async function startWatching(config) {
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(async () => {
       if (queueSize() > 0) {
-        const result = await processQueue(config, cases);
+        const result = await processQueue(config, cases, { smartMapper });
         if (result.uploaded > 0 || result.failed > 0) {
           log.info(
             `Batch: ${result.uploaded} uploaded, ${result.failed} failed`
@@ -1743,6 +2039,7 @@ async function startWatching(config) {
   startAIAgent({
     config,
     bootStats: { cases: cases.length, scanned, queued },
+    onboarding: opts?.onboarding,
     getCases: () => cases,
     refreshCases: async () => {
       cases = await listCases(config);
@@ -1753,7 +2050,7 @@ async function startWatching(config) {
       const result = await scanFolder(config);
       log.info(`Scanned ${result.scanned} files, ${result.queued} need syncing`);
       if (result.queued > 0) {
-        const syncResult = await processQueue(config, cases);
+        const syncResult = await processQueue(config, cases, { smartMapper });
         log.info(`Synced: ${syncResult.uploaded} uploaded, ${syncResult.failed} failed`);
       }
     },
@@ -1761,7 +2058,7 @@ async function startWatching(config) {
       await scanExternalFolder(config, folderPath, cases);
     },
     addWatchFolder: async (folderPath) => {
-      const absPath = resolve2(folderPath);
+      const absPath = resolve3(folderPath);
       if (!existsSync3(absPath) || !statSync2(absPath).isDirectory()) {
         return { added: false, error: `Not a valid directory: ${absPath}` };
       }
@@ -1774,7 +2071,7 @@ async function startWatching(config) {
       return { added: true, path: absPath };
     },
     removeWatchFolder: (folderPath) => {
-      const absPath = resolve2(folderPath);
+      const absPath = resolve3(folderPath);
       const result = removeWatchFolder(config, absPath);
       if (result.removed) {
         const w = watchers.get(absPath);
@@ -1875,13 +2172,34 @@ async function checkForUpdates(currentVersion) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname3, join as join4 } from "path";
 var __filename3 = fileURLToPath2(import.meta.url);
 var __dirname3 = dirname3(__filename3);
 var pkg = JSON.parse(readFileSync3(join4(__dirname3, "..", "package.json"), "utf-8"));
 await checkForUpdates(pkg.version);
+var HOME3 = homedir3();
+var FOLDER_SHORTCUTS2 = {
+  downloads: join4(HOME3, "Downloads"),
+  download: join4(HOME3, "Downloads"),
+  desktop: join4(HOME3, "Desktop"),
+  documents: join4(HOME3, "Documents"),
+  document: join4(HOME3, "Documents"),
+  home: HOME3,
+  "~": HOME3
+};
+function normalizeFolderPath(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return trimmed;
+  if (trimmed.startsWith("~/") || trimmed === "~") {
+    return resolve4(trimmed.replace(/^~/, HOME3));
+  }
+  const lower = trimmed.toLowerCase();
+  if (FOLDER_SHORTCUTS2[lower]) return FOLDER_SHORTCUTS2[lower];
+  const withoutSlash = lower.replace(/^\//, "");
+  if (FOLDER_SHORTCUTS2[withoutSlash]) return FOLDER_SHORTCUTS2[withoutSlash];
+  return resolve4(trimmed);
+}
 var program = new Command();
 program.name("anrak-sync").description("AnrakLegal desktop file sync \u2014 watches local folders, syncs to case management").version(pkg.version);
 program.command("init").description("Set up AnrakLegal Sync (first-time configuration)").option("--password", "Use email/password login instead of browser").action(async (opts) => {
@@ -1919,37 +2237,25 @@ program.command("init").description("Set up AnrakLegal Sync (first-time configur
       tokens = await browserLogin(apiUrl);
     }
     log.success("Authenticated");
-    const rl2 = createInterface2({ input: stdin2, output: stdout2 });
-    const defaultFolder = process.platform === "win32" ? "C:\\Cases" : `${process.env.HOME}/Cases`;
-    const watchInput = await rl2.question(
-      `  Watch folder ${chalk4.dim(`(${defaultFolder})`)}: `
-    );
-    const watchFolder = resolve3(watchInput || defaultFolder);
-    rl2.close();
-    if (!existsSync4(watchFolder)) {
-      log.warn(
-        `Folder ${watchFolder} does not exist \u2014 it will be created when you add files`
-      );
-    } else if (!statSync3(watchFolder).isDirectory()) {
-      log.error(`${watchFolder} is not a directory`);
-      process.exit(1);
+    try {
+      rl.close();
+    } catch {
     }
+    const defaultFolder = normalizeFolderPath("downloads");
     const config = {
       apiUrl,
       supabaseUrl: serverConfig.supabaseUrl,
       supabaseAnonKey: serverConfig.supabaseAnonKey,
       accessToken: tokens.accessToken,
       refreshToken: tokens.refreshToken,
-      watchFolder
+      watchFolder: defaultFolder
     };
     saveConfig(config);
     console.log("");
     log.success("Setup complete!");
     log.info(`Config saved to ${getConfigDir()}`);
-    log.info(`Watching: ${watchFolder}`);
-    console.log(
-      chalk4.dim("\n  Run `anrak-sync start` to begin syncing\n")
-    );
+    console.log("");
+    await startWatching(config, { onboarding: true });
   } catch (err) {
     log.error(err instanceof Error ? err.message : String(err));
     process.exit(1);

package/package.json

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