@anraktech/sync 0.13.1 → 0.14.0

package/dist/cli.js

@@ -454,6 +454,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 +540,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 +556,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 +564,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 +669,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 +682,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);
@@ -875,7 +979,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) {
@@ -974,6 +1090,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),
@@ -1506,8 +1644,26 @@ function startAIAgent(ctx) {
     }
   };
   let currentSlashArgs = "";
+  let lastPendingCount = 0;
   async function promptLoop() {
     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 +1714,7 @@ function startAIAgent(ctx) {
       while (history.length > 21) {
         history.splice(1, 1);
       }
+      history[0] = { role: "system", content: buildSystemPrompt(ctx.config) };
       try {
         const response = await agentTurn([...history], ctx);
         if (response) {
@@ -1573,6 +1730,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);
@@ -1673,10 +1916,11 @@ async function scanExternalFolder(config, folderPath, cases) {
 }
 async function startWatching(config) {
   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 +1937,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`
@@ -1753,7 +1997,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`);
       }
     },

package/package.json

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