rubrkit 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rubrkit",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "Rubrkit CLI for pulling artifact bundles into local agent projects.",
   "bin": {

package/src/sdk.js

@@ -1,9 +1,35 @@
 // @ts-check
 
+import { createHash } from 'node:crypto';
 import { DEFAULT_API_URL, normalizeApiUrl } from './config.js';
 
 const TERMINAL_JOB_STATES = new Set(['succeeded', 'failed', 'cancelled', 'paused']);
 
+/**
+ * Content hash matching the server's `computeContentHash` (sha256 of the UTF-8
+ * content bytes, prefixed `sha256:`). Used to detect which files changed.
+ *
+ * @param {string} content
+ * @returns {string}
+ */
+function contentHashOf(content) {
+    return `sha256:${createHash('sha256').update(Buffer.from(String(content), 'utf8')).digest('hex')}`;
+}
+
+/**
+ * Extracts the file array from a list-files API response, tolerant of the
+ * `{ data: { files } }` / `{ files } / [...]` envelope shapes.
+ *
+ * @param {unknown} listed
+ * @returns {Array<{ id: string, path: string, contentHash?: string }>}
+ */
+function extractBundleFiles(listed) {
+    const root = /** @type {any} */ (listed) || {};
+    const data = root.data ?? root.result ?? root;
+    const files = data?.files ?? data?.artifactFiles ?? (Array.isArray(data) ? data : []);
+    return Array.isArray(files) ? files : [];
+}
+
 /**
  * @typedef {{
  *   apiKey?: string | null,
@@ -112,6 +138,21 @@ export class Rubrkit {
                     body: omit(params, ['artifactBundleId']),
                 });
             },
+            update: (params = {}) => {
+                const artifactBundleId = requireParam(params, 'artifactBundleId');
+                const fileId = requireParam(params, 'fileId');
+                return this.request(`/artifact-bundles/${encodePath(artifactBundleId)}/files/${encodePath(fileId)}`, {
+                    method: 'PUT',
+                    body: omit(params, ['artifactBundleId', 'fileId']),
+                });
+            },
+            remove: (params = {}) => {
+                const artifactBundleId = requireParam(params, 'artifactBundleId');
+                const fileId = requireParam(params, 'fileId');
+                return this.request(`/artifact-bundles/${encodePath(artifactBundleId)}/files/${encodePath(fileId)}`, {
+                    method: 'DELETE',
+                });
+            },
             test: (params = {}) => this.startArtifactTest(params),
         };
 
@@ -222,6 +263,8 @@ export class Rubrkit {
         let upload = null;
 
         if (files.length > 0) {
+            const reuseExistingBundle = Boolean(artifactBundleId);
+
             if (!artifactBundleId) {
                 const created = await this.artifactBundles.create({
                     name: params.name ?? inferArtifactTestBundleName(files),
@@ -238,10 +281,13 @@ export class Rubrkit {
                 throw new RubrkitError('Rubrkit API response did not include an artifact bundle ID.', { code: 'missing_artifact_bundle_id' });
             }
 
-            upload = await this.artifacts.upload({
-                artifactBundleId,
-                files,
-            });
+            // A brand-new bundle is empty, so a plain create-upload is correct. An
+            // existing (pinned) bundle is synced: changed files are updated in place,
+            // new files added, and files no longer present are removed — so repeated
+            // runs don't conflict on already-present paths.
+            upload = reuseExistingBundle
+                ? await this.syncArtifactBundleFiles({ artifactBundleId, files, message: params.message })
+                : await this.artifacts.upload({ artifactBundleId, files });
         }
 
         if (!artifactBundleId) {
@@ -264,6 +310,65 @@ export class Rubrkit {
         };
     }
 
+    /**
+     * Mirrors a local file set into an existing artifact bundle: updates files
+     * whose content changed, creates new ones, and deletes files no longer
+     * present. Unchanged files (matching content hash) are left untouched, so
+     * re-running on the same content is a no-op instead of a path conflict.
+     *
+     * @param {{ artifactBundleId: string, files: Array<{ path: string, content: string, artifactType?: string }>, message?: string }} params
+     * @returns {Promise<{ created: string[], updated: string[], deleted: string[], unchanged: string[] }>}
+     */
+    async syncArtifactBundleFiles({ artifactBundleId, files, message }) {
+        // `limit` is capped at 200 by the API; a skills bundle is far smaller.
+        const existing = extractBundleFiles(await this.artifacts.list({ artifactBundleId, limit: 200 }));
+        const existingByPath = new Map(existing.map(file => [file.path, file]));
+
+        const created = [];
+        const updated = [];
+        const unchanged = [];
+        const toCreate = [];
+        const localPaths = new Set();
+
+        for (const file of files) {
+            localPaths.add(file.path);
+            const match = existingByPath.get(file.path);
+
+            if (!match) {
+                toCreate.push(file);
+                continue;
+            }
+
+            if (match.contentHash && match.contentHash === contentHashOf(file.content)) {
+                unchanged.push(file.path);
+                continue;
+            }
+
+            await this.artifacts.update({
+                artifactBundleId,
+                fileId: match.id,
+                content: file.content,
+                ...(message ? { message } : {}),
+            });
+            updated.push(file.path);
+        }
+
+        if (toCreate.length > 0) {
+            await this.artifacts.upload({ artifactBundleId, files: toCreate });
+            created.push(...toCreate.map(file => file.path));
+        }
+
+        const deleted = [];
+        for (const file of existing) {
+            if (!localPaths.has(file.path)) {
+                await this.artifacts.remove({ artifactBundleId, fileId: file.id });
+                deleted.push(file.path);
+            }
+        }
+
+        return { created, updated, deleted, unchanged };
+    }
+
     /**
      * @param {string} id
      * @param {JobWaitOptions} [options]