@regressionproof/snapshotter 0.5.3 → 0.5.4

package/build/.spruce/errors/errors.types.d.ts

@@ -6,6 +6,7 @@ export declare namespace SpruceErrors.RegressionproofSnapshotter {
         'command': string;
         'stdout'?: string | undefined | null;
         'stderr'?: string | undefined | null;
+        'version': string;
     }
     interface ExecCommandFailedSchema extends SpruceSchema.Schema {
         id: 'execCommandFailed';
@@ -29,6 +30,12 @@ export declare namespace SpruceErrors.RegressionproofSnapshotter {
                 type: 'text';
                 options: undefined;
             };
+            /** . */
+            'version': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
         };
     }
     type ExecCommandFailedEntity = SchemaEntity<SpruceErrors.RegressionproofSnapshotter.ExecCommandFailedSchema>;

package/build/.spruce/errors/regressionproofSnapshotter/execCommandFailed.schema.js

@@ -23,6 +23,12 @@ const execCommandFailedSchema = {
             type: 'text',
             options: undefined
         },
+        /** . */
+        'version': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
     }
 };
 schema_1.SchemaRegistry.getInstance().trackSchema(execCommandFailedSchema);

package/build/errors/SpruceError.js

@@ -25,7 +25,7 @@ ${options.stderr ?? '<no stderr>'}`;
         const fullMessage = options.friendlyMessage
             ? options.friendlyMessage
             : message;
-        return fullMessage;
+        return `${fullMessage} (v${options.version})`;
     }
 }
 exports.default = SpruceError;

package/build/errors/execCommandFailed.builder.d.ts

@@ -13,6 +13,10 @@ declare const _default: {
         stderr: {
             type: "text";
         };
+        version: {
+            type: "text";
+            isRequired: true;
+        };
     };
 };
 export default _default;

package/build/errors/execCommandFailed.builder.js

@@ -16,5 +16,9 @@ exports.default = (0, schema_1.buildErrorSchema)({
         stderr: {
             type: 'text',
         },
+        version: {
+            type: 'text',
+            isRequired: true,
+        },
     },
 });

package/build/esm/.spruce/errors/errors.types.d.ts

@@ -6,6 +6,7 @@ export declare namespace SpruceErrors.RegressionproofSnapshotter {
         'command': string;
         'stdout'?: string | undefined | null;
         'stderr'?: string | undefined | null;
+        'version': string;
     }
     interface ExecCommandFailedSchema extends SpruceSchema.Schema {
         id: 'execCommandFailed';
@@ -29,6 +30,12 @@ export declare namespace SpruceErrors.RegressionproofSnapshotter {
                 type: 'text';
                 options: undefined;
             };
+            /** . */
+            'version': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
         };
     }
     type ExecCommandFailedEntity = SchemaEntity<SpruceErrors.RegressionproofSnapshotter.ExecCommandFailedSchema>;

package/build/esm/errors/SpruceError.js

@@ -21,6 +21,6 @@ ${(_b = options.stderr) !== null && _b !== void 0 ? _b : '<no stderr>'}`;
         const fullMessage = options.friendlyMessage
             ? options.friendlyMessage
             : message;
-        return fullMessage;
+        return `${fullMessage} (v${options.version})`;
     }
 }

package/build/esm/errors/execCommandFailed.builder.d.ts

@@ -13,6 +13,10 @@ declare const _default: {
         stderr: {
             type: "text";
         };
+        version: {
+            type: "text";
+            isRequired: true;
+        };
     };
 };
 export default _default;

package/build/esm/errors/execCommandFailed.builder.js

@@ -14,5 +14,9 @@ export default buildErrorSchema({
         stderr: {
             type: 'text',
         },
+        version: {
+            type: 'text',
+            isRequired: true,
+        },
     },
 });

package/build/esm/git.js

@@ -12,6 +12,7 @@ import { existsSync } from 'fs';
 import path from 'path';
 import { promisify } from 'util';
 import SpruceError from './errors/SpruceError.js.js';
+import { getPackageVersion } from './utilities/version.js.js';
 const execAsync = promisify(exec);
 export function gitCommit(mirrorPath, log) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -40,30 +41,43 @@ export function gitPush(mirrorPath, remote, log) {
         else {
             yield execOrThrow(`git -C "${mirrorPath}" remote add origin "${authedUrl}"`);
         }
+        yield pullFromRemote(mirrorPath, log);
+        yield execOrThrow(`git -C "${mirrorPath}" push -u origin HEAD`, log);
+    });
+}
+function pullFromRemote(mirrorPath, log) {
+    return __awaiter(this, void 0, void 0, function* () {
         yield execOrThrow(`git -C "${mirrorPath}" fetch origin`, log);
-        if (yield hasRemoteHead(mirrorPath)) {
-            yield execOrThrow(`git -C "${mirrorPath}" rebase origin/HEAD`, log);
+        const branch = yield getCurrentBranch(mirrorPath);
+        const remoteBranchExists = yield checkRemoteBranchExists(mirrorPath, branch);
+        if (remoteBranchExists) {
+            yield execOrThrow(`git -C "${mirrorPath}" rebase origin/${branch}`, log);
         }
-        yield execOrThrow(`git -C "${mirrorPath}" push -u origin HEAD`, log);
     });
 }
-function remoteExists(mirrorPath, remoteName) {
+function getCurrentBranch(mirrorPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { stdout } = yield execAsync(`git -C "${mirrorPath}" rev-parse --abbrev-ref HEAD`);
+        return stdout.trim();
+    });
+}
+function checkRemoteBranchExists(mirrorPath, branch) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            const { stdout } = yield execAsync(`git -C "${mirrorPath}" remote`);
-            const remotes = stdout.trim().split('\n');
-            return remotes.includes(remoteName);
+            const { stdout } = yield execAsync(`git -C "${mirrorPath}" ls-remote --heads origin ${branch}`);
+            return stdout.trim().length > 0;
         }
         catch (_a) {
             return false;
         }
     });
 }
-function hasRemoteHead(mirrorPath) {
+function remoteExists(mirrorPath, remoteName) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            yield execAsync(`git -C "${mirrorPath}" symbolic-ref -q refs/remotes/origin/HEAD`);
-            return true;
+            const { stdout } = yield execAsync(`git -C "${mirrorPath}" remote`);
+            const remotes = stdout.trim().split('\n');
+            return remotes.includes(remoteName);
         }
         catch (_a) {
             return false;
@@ -86,6 +100,7 @@ function execOrThrow(command, log) {
                 command,
                 stdout,
                 stderr,
+                version: getPackageVersion(),
             });
         }
     });

package/build/esm/utilities/version.d.ts

@@ -0,0 +1 @@
+export declare function getPackageVersion(): string;

package/build/esm/utilities/version.js

@@ -0,0 +1,13 @@
+import { readFileSync } from 'node:fs';
+import path from 'path';
+export function getPackageVersion() {
+    var _a;
+    try {
+        const packagePath = path.join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+        return (_a = packageJson.version) !== null && _a !== void 0 ? _a : '*** unable to resolve version ***';
+    }
+    catch (_b) {
+        return '*** unable to resolve version ***';
+    }
+}

package/build/git.js

@@ -10,6 +10,7 @@ const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const util_1 = require("util");
 const SpruceError_js_1 = __importDefault(require("./errors/SpruceError.js"));
+const version_js_1 = require("./utilities/version.js");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 async function gitCommit(mirrorPath, log) {
     const gitDir = path_1.default.join(mirrorPath, '.git');
@@ -35,26 +36,35 @@ async function gitPush(mirrorPath, remote, log) {
     else {
         await execOrThrow(`git -C "${mirrorPath}" remote add origin "${authedUrl}"`);
     }
+    await pullFromRemote(mirrorPath, log);
+    await execOrThrow(`git -C "${mirrorPath}" push -u origin HEAD`, log);
+}
+async function pullFromRemote(mirrorPath, log) {
     await execOrThrow(`git -C "${mirrorPath}" fetch origin`, log);
-    if (await hasRemoteHead(mirrorPath)) {
-        await execOrThrow(`git -C "${mirrorPath}" rebase origin/HEAD`, log);
+    const branch = await getCurrentBranch(mirrorPath);
+    const remoteBranchExists = await checkRemoteBranchExists(mirrorPath, branch);
+    if (remoteBranchExists) {
+        await execOrThrow(`git -C "${mirrorPath}" rebase origin/${branch}`, log);
     }
-    await execOrThrow(`git -C "${mirrorPath}" push -u origin HEAD`, log);
 }
-async function remoteExists(mirrorPath, remoteName) {
+async function getCurrentBranch(mirrorPath) {
+    const { stdout } = await execAsync(`git -C "${mirrorPath}" rev-parse --abbrev-ref HEAD`);
+    return stdout.trim();
+}
+async function checkRemoteBranchExists(mirrorPath, branch) {
     try {
-        const { stdout } = await execAsync(`git -C "${mirrorPath}" remote`);
-        const remotes = stdout.trim().split('\n');
-        return remotes.includes(remoteName);
+        const { stdout } = await execAsync(`git -C "${mirrorPath}" ls-remote --heads origin ${branch}`);
+        return stdout.trim().length > 0;
     }
     catch {
         return false;
     }
 }
-async function hasRemoteHead(mirrorPath) {
+async function remoteExists(mirrorPath, remoteName) {
     try {
-        await execAsync(`git -C "${mirrorPath}" symbolic-ref -q refs/remotes/origin/HEAD`);
-        return true;
+        const { stdout } = await execAsync(`git -C "${mirrorPath}" remote`);
+        const remotes = stdout.trim().split('\n');
+        return remotes.includes(remoteName);
     }
     catch {
         return false;
@@ -74,6 +84,7 @@ async function execOrThrow(command, log) {
             command,
             stdout,
             stderr,
+            version: (0, version_js_1.getPackageVersion)(),
         });
     }
 }

package/build/utilities/version.d.ts

@@ -0,0 +1 @@
+export declare function getPackageVersion(): string;

package/build/utilities/version.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageVersion = getPackageVersion;
+const node_fs_1 = require("node:fs");
+const path_1 = __importDefault(require("path"));
+function getPackageVersion() {
+    try {
+        const packagePath = path_1.default.join(__dirname, '../../package.json');
+        const packageJson = JSON.parse((0, node_fs_1.readFileSync)(packagePath, 'utf-8'));
+        return packageJson.version ?? '*** unable to resolve version ***';
+    }
+    catch {
+        return '*** unable to resolve version ***';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@regressionproof/snapshotter",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "publishConfig": {
     "access": "public"
   },
@@ -94,5 +94,5 @@
     "@sprucelabs/spruce-core-schemas": "^42.1.3",
     "@sprucelabs/spruce-skill-utils": "^34.0.3"
   },
-  "gitHead": "d54c041a4d6b4cd88d35025ef1ee6d9acb6ad664"
+  "gitHead": "01c36085fc6f8c0fdc7778de7f7dee6e194cb3f4"
 }