@hiveku-apps/sync 0.3.5 → 0.4.0

package/src/saveFiles.mjs

@@ -0,0 +1,111 @@
+/**
+ * Save code files to Hiveku in batches with project_files_bulk_save, and say
+ * exactly which ones did not land.
+ *
+ * On Your site the route writes files one by one and stops at an 85 s wall
+ * budget (the edge would otherwise close the request): it answers 207 with
+ * `partial: true` and `remaining_paths`, the files it did NOT attempt, which
+ * are not in `results[]`. Its own hint: call again with ONLY the files in
+ * remaining_paths, never the whole batch. So each batch is sent once, then
+ * once more with only what did not land (ok:false results plus
+ * remaining_paths); whatever still has not landed is reported as not saved.
+ * A file is counted as saved once, however many times it was sent.
+ *
+ * A branch save answers the branch's new `working_tree_etag`; the last one
+ * is returned so the caller can record which tree its push left behind.
+ *
+ * Builder contract: hiveku_builder feature/versions-core
+ * src/app/api/olympus/builder/projects/[projectId]/files-bulk/route.ts (POST).
+ */
+
+/** Batches of about 25 text files finish inside the route's time budget (the tool's own advice). */
+export const BATCH_FILES = 25;
+/** Well under the route's 20 MB cap; sized for MCP transport reliability. */
+export const BATCH_BYTES = 4_000_000;
+const ATTEMPTS = 2;
+
+/** Split files into batches of at most BATCH_FILES files and BATCH_BYTES of content. */
+export function batchFiles(files, { maxFiles = BATCH_FILES, maxBytes = BATCH_BYTES } = {}) {
+  const batches = [];
+  let batch = [];
+  let bytes = 0;
+  for (const file of files) {
+    const size = String(file.content ?? '').length;
+    if (batch.length >= maxFiles || (bytes > 0 && bytes + size > maxBytes)) {
+      batches.push(batch);
+      batch = [];
+      bytes = 0;
+    }
+    batch.push(file);
+    bytes += size;
+  }
+  if (batch.length) batches.push(batch);
+  return batches;
+}
+
+/**
+ * Read one bulk_save answer for the files that were sent: which landed, which
+ * did not, and the branch etag. `results[]` names each file the route tried
+ * and `remaining_paths` the ones it did not try. A file the answer does not
+ * name counts as landed only when `summary.succeeded` accounts for it (an
+ * older answer carries the summary alone), else as not landed.
+ */
+export function readSaveAnswer(data, sentPaths) {
+  if (!data || typeof data !== 'object') return { landed: [], notLanded: [...sentPaths], etag: null };
+  const sent = new Set(sentPaths);
+  const results = Array.isArray(data.results) ? data.results.filter((r) => r && sent.has(r.path)) : [];
+  const notLanded = new Set([
+    ...results.filter((r) => r.ok === false).map((r) => r.path),
+    ...(Array.isArray(data.remaining_paths) ? data.remaining_paths.filter((p) => sent.has(p)) : []),
+  ]);
+  const landed = new Set(results.filter((r) => r.ok !== false && !notLanded.has(r.path)).map((r) => r.path));
+  const unnamed = sentPaths.filter((p) => !landed.has(p) && !notLanded.has(p));
+  if (unnamed.length) {
+    const succeeded = typeof data.summary?.succeeded === 'number' ? data.summary.succeeded : null;
+    const restLanded = succeeded === null ? notLanded.size === 0 : succeeded - landed.size >= unnamed.length;
+    for (const p of unnamed) (restLanded ? landed : notLanded).add(p);
+  }
+  const etag = typeof data.working_tree_etag === 'string' && data.working_tree_etag ? data.working_tree_etag : null;
+  return { landed: [...landed], notLanded: [...notLanded], etag };
+}
+
+/**
+ * Save `files` ({ path, content, encoding }) to Your site (branch null) or a
+ * branch. Returns { saved, failed: [paths], workingTreeEtag }. Never throws for
+ * a refused or failed call: those files are reported in `failed`.
+ */
+export async function saveCodeFiles({ client, projectId, files, branch = null, note, log = () => {} }) {
+  const savedPaths = new Set();
+  const failed = [];
+  let workingTreeEtag = null;
+  const total = files.length;
+  for (const batch of batchFiles(files)) {
+    let pending = batch;
+    for (let attempt = 1; attempt <= ATTEMPTS && pending.length; attempt++) {
+      const sentPaths = pending.map((f) => f.path);
+      let data;
+      try {
+        data = (
+          await client.callToolJson('project_files_bulk_save', {
+            project_id: projectId,
+            files: pending.map((f) => ({ path: f.path, content: f.content, encoding: f.encoding })),
+            // A note on each file's row, never a version (the version is saved once, after every file).
+            commit_message: note,
+            ...(branch ? { branch } : {}),
+          })
+        )?.data;
+      } catch {
+        // No answer: nothing is known about this batch, so all of it is sent again.
+        continue;
+      }
+      const answer = readSaveAnswer(data, sentPaths);
+      for (const p of answer.landed) savedPaths.add(p);
+      if (answer.etag) workingTreeEtag = answer.etag;
+      const again = new Set(answer.notLanded);
+      pending = pending.filter((f) => again.has(f.path) && !savedPaths.has(f.path));
+    }
+    failed.push(...pending.map((f) => f.path));
+    log(`  code ${savedPaths.size}/${total}`);
+  }
+  return { saved: savedPaths.size, failed, workingTreeEtag };
+}