devark-cli 0.1.0 → 0.1.3

package/dist/checksums.sha256

@@ -1,3 +1,3 @@
-52a46eee13d20a05fc798ac3e30f00685cf9475e3a56a48ede86461cd5d56ee1  index.js
-6e948721c1e5bb7dd3e746c0e1e7a972cbd491b6f0135718178b22563ca56de9  index.js.map
+4e5508903ce1d478e710b2b659be710be26dd3e4233ac1fde8fce9b6a81cb37a  index.js
+1af5bc655dd375bcbda2a0274b9441baeebdf921d615302c3c224706f34675cf  index.js.map
 137b0f6da8ab3a82dd96e536c9de1c0162f51d5450895af16e935906975671a8  report-template.html

package/dist/index.js

@@ -2481,7 +2481,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "devark-cli",
-      version: "0.1.0",
+      version: "0.1.3",
       description: "DevArk - Developer Productivity CLI",
       bin: {
         devark: "./bin/devark.js"
@@ -2668,7 +2668,7 @@ async function gatherCLIConfiguration() {
     return null;
   }
 }
-var import_axios, import_crypto2, SecureApiClient, apiClient;
+var import_axios, import_crypto2, TARGET_BATCH_SIZE_BYTES, BUFFER_PERCENT, SecureApiClient, apiClient;
 var init_api_client = __esm({
   "src/lib/api-client.ts"() {
     "use strict";
@@ -2681,6 +2681,8 @@ var init_api_client = __esm({
     init_network_errors();
     init_claude_settings_manager();
     import_crypto2 = __toESM(require("crypto"));
+    TARGET_BATCH_SIZE_BYTES = 500 * 1024;
+    BUFFER_PERCENT = 0.2;
     SecureApiClient = class {
       client;
       requestCount = 0;
@@ -2894,20 +2896,45 @@ var init_api_client = __esm({
           return { valid: false };
         }
       }
+      estimateSessionSize(session) {
+        return Buffer.byteLength(JSON.stringify(session));
+      }
+      createSizeBatches(sessions, targetSizeBytes = TARGET_BATCH_SIZE_BYTES, bufferPercent = BUFFER_PERCENT) {
+        const effectiveTarget = targetSizeBytes * (1 - bufferPercent);
+        const batches = [];
+        let currentBatch = [];
+        let currentSize = 0;
+        for (const session of sessions) {
+          const sessionSize = this.estimateSessionSize(session);
+          if (currentBatch.length > 0 && currentSize + sessionSize > effectiveTarget) {
+            batches.push(currentBatch);
+            currentBatch = [session];
+            currentSize = sessionSize;
+          } else {
+            currentBatch.push(session);
+            currentSize += sessionSize;
+          }
+        }
+        if (currentBatch.length > 0) {
+          batches.push(currentBatch);
+        }
+        return batches;
+      }
       async uploadSessions(sessions, onProgress) {
         const cliConfig = await gatherCLIConfiguration();
         const sanitizedSessions = sessions.map((session) => this.sanitizeSession(session));
-        const CHUNK_SIZE = 100;
-        const chunks = [];
-        for (let i = 0; i < sanitizedSessions.length; i += CHUNK_SIZE) {
-          chunks.push(sanitizedSessions.slice(i, i + CHUNK_SIZE));
-        }
+        const chunks = this.createSizeBatches(sanitizedSessions);
         const results = [];
         let uploadedCount = 0;
         let uploadedSizeKB = 0;
         const totalSize = Buffer.byteLength(JSON.stringify(sanitizedSessions)) / 1024;
         if (process.env.DEVARK_DEBUG === "true") {
-          console.log("[DEBUG] Uploading in", chunks.length, "chunks", `(Total: ${totalSize.toFixed(2)} KB)`);
+          console.log(
+            "[DEBUG] Uploading in",
+            chunks.length,
+            "size-based batches",
+            `(Total: ${totalSize.toFixed(2)} KB, Target: ~${TARGET_BATCH_SIZE_BYTES / 1024}KB per batch)`
+          );
         }
         for (let i = 0; i < chunks.length; i++) {
           const chunk = chunks[i];
@@ -3060,6 +3087,25 @@ var init_api_client = __esm({
         }
         return response.data;
       }
+      /**
+       * Get the timestamp of the user's most recent session for incremental sync.
+       * @returns Last session timestamp (ISO string) and ID, or null if no sessions exist
+       */
+      async getLastSessionDate() {
+        var _a;
+        try {
+          const response = await this.client.get("/api/sessions/last");
+          return {
+            lastSessionTimestamp: response.data.lastSessionTimestamp || null,
+            lastSessionId: response.data.lastSessionId || null
+          };
+        } catch (error) {
+          if (((_a = error.response) == null ? void 0 : _a.status) === 404) {
+            return { lastSessionTimestamp: null, lastSessionId: null };
+          }
+          throw error;
+        }
+      }
       getBaseUrl() {
         return this.client.defaults.baseURL || "http://localhost:3000";
       }
@@ -4010,10 +4056,14 @@ var init_send_orchestrator = __esm({
           return this.readSelectedSessions(options.selectedSessions);
         }
         if (options.all) {
-          const sessions2 = await readClaudeSessions({ since: void 0 });
+          const serverSince = await this.getServerLastSessionDate();
+          if (serverSince) {
+            logger.debug(`Using server timestamp for incremental sync: ${serverSince.toISOString()}`);
+          }
+          const sessions2 = await readClaudeSessions({ since: serverSince });
           return sessions2;
         }
-        const sinceDate = this.determineSinceDate(options);
+        const sinceDate = await this.determineSinceDateWithServerFallback(options);
         if (options.claudeProjectDir && options.claudeProjectDir.trim() !== "") {
           return this.loadProjectSessions(options.claudeProjectDir, sinceDate);
         }
@@ -4036,6 +4086,34 @@ var init_send_orchestrator = __esm({
         }
         return void 0;
       }
+      /**
+       * Get the server's last session timestamp for incremental sync.
+       * Returns undefined on error to allow fallback to local sync state.
+       */
+      async getServerLastSessionDate() {
+        try {
+          const result = await apiClient.getLastSessionDate();
+          if (result.lastSessionTimestamp) {
+            return new Date(result.lastSessionTimestamp);
+          }
+          return void 0;
+        } catch (error) {
+          logger.warn(`Failed to get server last session date, falling back to local sync: ${error instanceof Error ? error.message : "Unknown error"}`);
+          return void 0;
+        }
+      }
+      /**
+       * Determine since date with server-side incremental sync fallback.
+       * First tries server timestamp, then falls back to local sync state.
+       */
+      async determineSinceDateWithServerFallback(options) {
+        const serverSince = await this.getServerLastSessionDate();
+        if (serverSince) {
+          logger.debug(`Using server timestamp for incremental sync: ${serverSince.toISOString()}`);
+          return serverSince;
+        }
+        return this.determineSinceDate(options);
+      }
       async loadProjectSessions(claudeProjectDir, sinceDate) {
         const dirName = parseProjectName(claudeProjectDir);
         const project = await analyzeProject(claudeProjectDir, dirName);
@@ -11422,6 +11500,20 @@ var manual_sync_menu_exports = {};
 __export(manual_sync_menu_exports, {
   showManualSyncMenu: () => showManualSyncMenu
 });
+async function getServerLastSessionDate() {
+  try {
+    if (!await isAuthenticated()) {
+      return void 0;
+    }
+    const result = await apiClient.getLastSessionDate();
+    if (result.lastSessionTimestamp) {
+      return new Date(result.lastSessionTimestamp);
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
 async function showManualSyncMenu() {
   console.log("");
   console.log(colors.primary("Manual sync to cloud"));
@@ -11562,22 +11654,39 @@ async function showManualSyncMenu() {
       }
     }
     case "all": {
-      const projects = await discoverProjects();
-      const totalSessions = projects.reduce((sum, p) => sum + p.sessions, 0);
-      console.log("");
-      console.log(colors.info(`This will sync ${totalSessions} sessions from ${projects.length} projects.`));
-      const { confirm } = await import_inquirer14.default.prompt([
-        {
-          type: "confirm",
-          name: "confirm",
-          message: "Continue with syncing all projects?",
-          default: true
+      const spinner = createSpinner("Calculating sessions to sync...").start();
+      try {
+        const serverSince = await getServerLastSessionDate();
+        const sessions = await readClaudeSessions({ since: serverSince });
+        const validSessions = sessions.filter((s) => s.duration >= 240);
+        const projectPaths = new Set(validSessions.map((s) => {
+          var _a;
+          return (_a = s.sourceFile) == null ? void 0 : _a.claudeProjectPath;
+        }).filter(Boolean));
+        spinner.stop();
+        console.log("");
+        if (serverSince) {
+          console.log(colors.info(`This will sync ${validSessions.length} new sessions from ${projectPaths.size} projects`));
+          console.log(colors.subdued(`(Sessions since ${serverSince.toLocaleDateString()})`));
+        } else {
+          console.log(colors.info(`This will sync ${validSessions.length} sessions from ${projectPaths.size} projects.`));
         }
-      ]);
-      if (!confirm) {
+        const { confirm } = await import_inquirer14.default.prompt([
+          {
+            type: "confirm",
+            name: "confirm",
+            message: `Continue with syncing ${validSessions.length} sessions?`,
+            default: true
+          }
+        ]);
+        if (!confirm) {
+          return { type: "cancel" };
+        }
+        return { type: "all" };
+      } catch (error) {
+        spinner.fail(colors.error("Failed to calculate sessions"));
         return { type: "cancel" };
       }
-      return { type: "all" };
     }
     default:
       return { type: "cancel" };
@@ -11595,6 +11704,8 @@ var init_manual_sync_menu = __esm({
     init_claude();
     init_project_display();
     init_ui();
+    init_api_client();
+    init_token();
   }
 });
 
@@ -15608,7 +15719,7 @@ function createSection(title, content, options) {
   lines.push(color(chars.bl + chars.h.repeat(width - 2) + chars.br));
   return lines.join("\n");
 }
-function createCloudStatusSection(status2) {
+function createCloudStatusSection(status2, serverLastSessionDate) {
   const content = [];
   const connectionIcon = status2.connected ? icons.success : icons.error;
   const connectionColor = status2.connected ? colors.success : colors.error;
@@ -15636,12 +15747,13 @@ function createCloudStatusSection(status2) {
   let syncColor = colors.primary;
   let syncText = "Never synced";
   let syncProject = "";
-  if (status2.lastSync) {
-    const timeSince = (/* @__PURE__ */ new Date()).getTime() - status2.lastSync.getTime();
+  const lastSyncDate = serverLastSessionDate || status2.lastSync;
+  if (lastSyncDate) {
+    const timeSince = (/* @__PURE__ */ new Date()).getTime() - lastSyncDate.getTime();
     const minutes = Math.floor(timeSince / 6e4);
     const hours = Math.floor(minutes / 60);
     const days = Math.floor(hours / 24);
-    if (status2.lastSyncProject) {
+    if (!serverLastSessionDate && status2.lastSyncProject) {
       syncProject = `${status2.lastSyncProject} `;
     }
     if (days > 0) {
@@ -15722,9 +15834,9 @@ function createLocalEngineSection(engine) {
     color: sectionColor
   });
 }
-async function createStatusDashboard(cloud, local) {
+async function createStatusDashboard(cloud, local, serverLastSessionDate) {
   const sections = [];
-  sections.push(createCloudStatusSection(cloud));
+  sections.push(createCloudStatusSection(cloud, serverLastSessionDate));
   sections.push("");
   sections.push(createLocalEngineSection(local));
   return sections.join("\n");
@@ -16135,7 +16247,18 @@ async function showMainMenu(state, packageUpdateInfo2) {
     statusLineStatus: state.statusLineStatus,
     configPath: "~/.claude/config"
   };
-  console.log(await createStatusDashboard(cloudStatus, localEngine));
+  let serverLastSessionDate;
+  if (state.hasAuth) {
+    try {
+      const { apiClient: apiClient2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
+      const result = await apiClient2.getLastSessionDate();
+      if (result.lastSessionTimestamp) {
+        serverLastSessionDate = new Date(result.lastSessionTimestamp);
+      }
+    } catch {
+    }
+  }
+  console.log(await createStatusDashboard(cloudStatus, localEngine, serverLastSessionDate));
   console.log("");
   const context = {
     state: state.state,