@anraktech/sync 0.2.1 → 0.4.0

package/dist/cli.js

@@ -418,9 +418,6 @@ function resetCache() {
 import { watch } from "chokidar";
 import { readdirSync, statSync, existsSync as existsSync2 } from "fs";
 import { join as join2, relative as relative2, basename as basename4, resolve } from "path";
-import { createInterface } from "readline/promises";
-import { stdin, stdout } from "process";
-import chalk2 from "chalk";
 
 // src/uploader.ts
 import { stat as stat2 } from "fs/promises";
@@ -619,6 +616,300 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
+// src/agent.ts
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+import chalk2 from "chalk";
+var TOOLS = [
+  {
+    type: "function",
+    function: {
+      name: "scan_folder",
+      description: "Scan a local folder on the user's computer and sync all supported files (PDF, DOCX, etc.) to a matching legal case. Use when user asks to scan, sync, upload, or look at a specific folder.",
+      parameters: {
+        type: "object",
+        properties: {
+          folderPath: {
+            type: "string",
+            description: "Absolute path to the folder, e.g. /Users/name/Downloads"
+          }
+        },
+        required: ["folderPath"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_cases",
+      description: "List all legal cases on the server with case numbers, names, and document counts.",
+      parameters: { type: "object", properties: {} }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "get_status",
+      description: "Show sync stats: files tracked, synced, pending, errors, queue size.",
+      parameters: { type: "object", properties: {} }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "get_mappings",
+      description: "Show which local folders are mapped to which legal cases.",
+      parameters: { type: "object", properties: {} }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "refresh_cases",
+      description: "Refresh the case list from the server.",
+      parameters: { type: "object", properties: {} }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "rescan_watch_folder",
+      description: "Re-scan the watch folder for new or changed files and sync them.",
+      parameters: { type: "object", properties: {} }
+    }
+  }
+];
+function buildSystemPrompt(config) {
+  return `You are AnrakLegal Sync, a terminal assistant that helps lawyers sync local files to their case management system.
+
+Watch folder: ${config.watchFolder}
+Server: ${config.apiUrl}
+
+You can scan folders, list cases, show sync status, and more using your tools.
+
+Rules:
+- Be concise. This is a terminal \u2014 1-3 lines unless showing a list.
+- Do NOT use markdown. Plain text only.
+- When user mentions a folder like "downloads" or "desktop", expand to full path (macOS: /Users/<name>/Downloads, Windows: C:\\Users\\<name>\\Downloads).
+- Call tools to perform actions. Summarize results naturally after.
+- Do NOT use thinking tags or reasoning tags in your output.`;
+}
+async function executeTool(name, args, ctx) {
+  switch (name) {
+    case "scan_folder": {
+      const folderPath = args.folderPath;
+      if (!folderPath) return JSON.stringify({ error: "Missing folderPath" });
+      try {
+        await ctx.scanFolder(folderPath);
+        const stats = getStats();
+        return JSON.stringify({
+          success: true,
+          folderPath,
+          totalFiles: stats.totalFiles,
+          synced: stats.synced,
+          pending: stats.pending,
+          errors: stats.errors
+        });
+      } catch (err) {
+        return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    case "list_cases": {
+      await ctx.refreshCases();
+      const cases = ctx.getCases();
+      return JSON.stringify(
+        cases.map((c) => ({
+          caseNumber: c.caseNumber,
+          caseName: c.caseName,
+          status: c.status,
+          documents: c.documents?.length ?? 0
+        }))
+      );
+    }
+    case "get_status": {
+      const stats = getStats();
+      return JSON.stringify({ ...stats, queueSize: queueSize() });
+    }
+    case "get_mappings": {
+      const mappings = getAllMappings();
+      return JSON.stringify(
+        Object.entries(mappings).map(([folder, m]) => ({
+          folder,
+          caseNumber: m.caseNumber,
+          caseName: m.caseName
+        }))
+      );
+    }
+    case "refresh_cases": {
+      await ctx.refreshCases();
+      return JSON.stringify({ success: true, caseCount: ctx.getCases().length });
+    }
+    case "rescan_watch_folder": {
+      await ctx.triggerScan();
+      const stats = getStats();
+      return JSON.stringify({
+        success: true,
+        totalFiles: stats.totalFiles,
+        synced: stats.synced,
+        pending: stats.pending
+      });
+    }
+    default:
+      return JSON.stringify({ error: `Unknown tool: ${name}` });
+  }
+}
+async function* parseSSE(response) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop();
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || !trimmed.startsWith("data: ")) continue;
+      const data = trimmed.slice(6);
+      if (data === "[DONE]") return;
+      try {
+        const parsed = JSON.parse(data);
+        const choice = parsed.choices?.[0];
+        if (choice?.delta) {
+          yield { delta: choice.delta, finishReason: choice.finish_reason ?? null };
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function agentTurn(messages, ctx) {
+  const token = await getAccessToken(ctx.config);
+  const response = await fetch(`${ctx.config.apiUrl}/api/sync/chat`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ messages, tools: TOOLS })
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Server error (${response.status}): ${body.slice(0, 200)}`);
+  }
+  let textContent = "";
+  const toolCalls = /* @__PURE__ */ new Map();
+  let isFirstText = true;
+  for await (const { delta } of parseSSE(response)) {
+    if (delta.content) {
+      if (isFirstText) {
+        process.stdout.write("  ");
+        isFirstText = false;
+      }
+      const cleaned = delta.content.replace(/<\/?think>/g, "");
+      if (cleaned) {
+        process.stdout.write(cleaned);
+        textContent += cleaned;
+      }
+    }
+    if (delta.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        const existing = toolCalls.get(tc.index);
+        if (existing) {
+          if (tc.function?.arguments) existing.args += tc.function.arguments;
+        } else {
+          toolCalls.set(tc.index, {
+            id: tc.id ?? `call_${tc.index}`,
+            name: tc.function?.name ?? "",
+            args: tc.function?.arguments ?? ""
+          });
+        }
+      }
+    }
+  }
+  if (textContent) {
+    process.stdout.write("\n");
+  }
+  if (toolCalls.size === 0) {
+    return textContent;
+  }
+  const assistantMsg = {
+    role: "assistant",
+    content: textContent || null,
+    tool_calls: Array.from(toolCalls.values()).map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: { name: tc.name, arguments: tc.args }
+    }))
+  };
+  messages.push(assistantMsg);
+  for (const tc of toolCalls.values()) {
+    process.stdout.write(chalk2.dim(`  \u27F3 ${tc.name}...
+`));
+    let args = {};
+    try {
+      args = JSON.parse(tc.args || "{}");
+    } catch {
+    }
+    const result = await executeTool(tc.name, args, ctx);
+    messages.push({ role: "tool", content: result, tool_call_id: tc.id });
+  }
+  return agentTurn(messages, ctx);
+}
+function startAIAgent(ctx) {
+  const history = [
+    { role: "system", content: buildSystemPrompt(ctx.config) }
+  ];
+  const rl = createInterface({ input: stdin, output: stdout });
+  console.log("");
+  console.log(chalk2.bold("  AnrakLegal Sync"));
+  console.log(chalk2.dim(`  Watching ${ctx.config.watchFolder}`));
+  console.log(chalk2.dim(`  Connected to ${ctx.config.apiUrl}`));
+  console.log("");
+  console.log(
+    chalk2.dim("  Ask me anything \u2014 scan folders, check cases, show status.")
+  );
+  console.log(chalk2.dim('  Type "quit" to exit.\n'));
+  const PROMPT = `${chalk2.bold.blue("\u276F")} `;
+  async function promptLoop() {
+    while (true) {
+      let input;
+      try {
+        input = await rl.question(PROMPT);
+      } catch {
+        break;
+      }
+      const trimmed = input.trim();
+      if (!trimmed) continue;
+      if (/^(quit|exit|q)$/i.test(trimmed)) {
+        process.emit("SIGINT");
+        return;
+      }
+      if (/^(clear|reset|new)$/i.test(trimmed)) {
+        history.length = 1;
+        console.log(chalk2.dim("  Conversation cleared.\n"));
+        continue;
+      }
+      history.push({ role: "user", content: trimmed });
+      while (history.length > 21) {
+        history.splice(1, 1);
+      }
+      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("");
+    }
+  }
+  void promptLoop();
+}
+
 // src/watcher.ts
 async function scanFolder(config) {
   const folder = config.watchFolder;
@@ -714,129 +1005,6 @@ async function scanExternalFolder(config, folderPath, cases) {
     log.success("Everything up to date");
   }
 }
-function startInteractiveAgent(config, getCases, refreshCases, triggerScan) {
-  const PROMPT = chalk2.blue("anrak> ");
-  const rl = createInterface({ input: stdin, output: stdout });
-  function showHelp() {
-    console.log("");
-    console.log(chalk2.bold("  Available commands:"));
-    console.log("");
-    console.log(`  ${chalk2.cyan("scan <folder>")}     Scan a folder and sync its files to a case`);
-    console.log(`  ${chalk2.cyan("rescan")}            Re-scan the watch folder for new files`);
-    console.log(`  ${chalk2.cyan("cases")}             List cases on the server`);
-    console.log(`  ${chalk2.cyan("status")}            Show sync statistics`);
-    console.log(`  ${chalk2.cyan("mappings")}          Show folder \u2192 case mappings`);
-    console.log(`  ${chalk2.cyan("refresh")}           Refresh cases from server`);
-    console.log(`  ${chalk2.cyan("help")}              Show this help`);
-    console.log(`  ${chalk2.cyan("quit")}              Stop syncing and exit`);
-    console.log("");
-  }
-  async function handleCommand(input) {
-    const trimmed = input.trim();
-    if (!trimmed) return;
-    const [cmd, ...args] = trimmed.split(/\s+/);
-    const arg = args.join(" ");
-    switch (cmd.toLowerCase()) {
-      case "scan": {
-        if (!arg) {
-          log.warn("Usage: scan <folder path>");
-          break;
-        }
-        await scanExternalFolder(config, arg, getCases());
-        break;
-      }
-      case "rescan": {
-        await triggerScan();
-        break;
-      }
-      case "cases": {
-        await refreshCases();
-        const cases = getCases();
-        if (cases.length === 0) {
-          log.info("No cases found on server");
-        } else {
-          console.log("");
-          for (const c of cases) {
-            const docCount = c.documents?.length ?? 0;
-            console.log(
-              `  ${chalk2.cyan(c.caseNumber)} ${c.caseName} ${chalk2.dim(`(${docCount} docs)`)}`
-            );
-          }
-          console.log("");
-        }
-        break;
-      }
-      case "status": {
-        const stats = getStats();
-        console.log("");
-        console.log(`  ${chalk2.bold("Watch folder:")}   ${config.watchFolder}`);
-        console.log(`  ${chalk2.bold("Files tracked:")}  ${stats.totalFiles}`);
-        console.log(`  ${chalk2.bold("Synced:")}         ${chalk2.green(String(stats.synced))}`);
-        console.log(`  ${chalk2.bold("Pending:")}        ${chalk2.yellow(String(stats.pending))}`);
-        console.log(`  ${chalk2.bold("Errors:")}         ${chalk2.red(String(stats.errors))}`);
-        console.log(`  ${chalk2.bold("Mapped folders:")} ${stats.mappedFolders}`);
-        console.log(`  ${chalk2.bold("Queue:")}          ${queueSize()}`);
-        console.log("");
-        break;
-      }
-      case "mappings":
-      case "map": {
-        const mappings = getAllMappings();
-        const entries = Object.entries(mappings);
-        if (entries.length === 0) {
-          log.info("No folder mappings yet");
-        } else {
-          console.log("");
-          for (const [folder, m] of entries) {
-            console.log(
-              `  ${chalk2.cyan(folder)} \u2192 ${m.caseNumber} ${chalk2.dim(`(${m.caseName})`)}`
-            );
-          }
-          console.log("");
-        }
-        break;
-      }
-      case "refresh": {
-        log.info("Refreshing cases from server...");
-        await refreshCases();
-        log.success(`Found ${getCases().length} case(s)`);
-        break;
-      }
-      case "help":
-      case "?": {
-        showHelp();
-        break;
-      }
-      case "quit":
-      case "exit":
-      case "q": {
-        process.emit("SIGINT");
-        return;
-      }
-      default: {
-        log.warn(`Unknown command: ${cmd}. Type ${chalk2.cyan("help")} for available commands.`);
-        break;
-      }
-    }
-  }
-  showHelp();
-  async function promptLoop() {
-    while (true) {
-      let input;
-      try {
-        input = await rl.question(PROMPT);
-      } catch {
-        break;
-      }
-      try {
-        await handleCommand(input);
-      } catch (err) {
-        log.error(err instanceof Error ? err.message : String(err));
-      }
-    }
-  }
-  void promptLoop();
-}
 async function startWatching(config) {
   const folder = config.watchFolder;
   log.info(`Scanning ${folder}...`);
@@ -904,13 +1072,13 @@ async function startWatching(config) {
   watcher.on("error", (err) => {
     log.error(`Watcher error: ${err instanceof Error ? err.message : String(err)}`);
   });
-  startInteractiveAgent(
+  startAIAgent({
     config,
-    () => cases,
-    async () => {
+    getCases: () => cases,
+    refreshCases: async () => {
       cases = await listCases(config);
     },
-    async () => {
+    triggerScan: async () => {
       log.info(`Re-scanning ${folder}...`);
       const result = await scanFolder(config);
       log.info(`Scanned ${result.scanned} files, ${result.queued} need syncing`);
@@ -918,8 +1086,11 @@ async function startWatching(config) {
         const syncResult = await processQueue(config, cases);
         log.info(`Synced: ${syncResult.uploaded} uploaded, ${syncResult.failed} failed`);
       }
+    },
+    scanFolder: async (folderPath) => {
+      await scanExternalFolder(config, folderPath, cases);
     }
-  );
+  });
   const shutdown = () => {
     log.info("Shutting down...");
     clearInterval(refreshInterval);

package/package.json

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