@bevel-software/platform-core-backend 0.4.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bevel-software/platform-core-backend",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Open-source core backend of the Bevel platform: git-backed knowledge workspace, workflow (branches/change requests/locks/SSE), skills, tools, secrets vault, access control and the remote MCP surface.",
   "type": "module",
   "main": "./dist/index.js",
@@ -45,7 +45,7 @@
     "pg": "^8.20.0",
     "yaml": "^2.9.0",
     "zod": "^3.24.0",
-    "@bevel-software/platform-shared": "0.4.0"
+    "@bevel-software/platform-shared": "0.4.1"
   },
   "devDependencies": {
     "@types/adm-zip": "^0.5.8",

package/src/modules/workflow/__tests__/pending-commits.enqueue-if-absent.test.ts

@@ -1,72 +1,82 @@
-import { describe, expect, it, vi } from 'vitest';
-import { PendingCommitsService } from '../pending-commits.service.js';
-import type { Database } from '../../database/connection.js';
-
-/**
- * `enqueueIfAbsent` backs the pull-conflict recovery dispatch: it must
- * insert only when NO row exists for the (workspace, branch, path) in ANY
- * status. A plain `enqueue` would refresh an existing pending row and reset
- * its retry counters — and the dispatch path fires on every sync attempt,
- * so those resets would starve the worker's ladder and the recovery agent
- * would never spawn. A `needs_attention` row must also block re-entry (the
- * ladder already escalated to a human; more agent runs are just a loop).
- *
- * Fake drizzle chain, same shape as the vault tests — the queue's SQL-level
- * behavior (claim fencing etc.) is covered elsewhere; this pins the
- * check-then-insert decision logic.
- */
-function makeFakeDb(existingCount: number) {
-  const inserted: unknown[] = [];
-  const selectChain: any = {};
-  selectChain.from = vi.fn(() => selectChain);
-  selectChain.where = vi.fn(() => selectChain);
-  selectChain.then = (onF: any, onR: any) =>
-    Promise.resolve([{ count: existingCount }]).then(onF, onR);
-  const insertChain: any = {};
-  insertChain.values = vi.fn((v: unknown) => {
-    inserted.push(v);
-    return insertChain;
-  });
-  insertChain.then = (onF: any, onR: any) => Promise.resolve(undefined).then(onF, onR);
-  const db = {
-    select: vi.fn(() => selectChain),
-    insert: vi.fn(() => insertChain),
-  } as unknown as Database;
-  return { db, inserted };
-}
-
-const INPUT = {
-  workspaceId: 'razvan.radulescu/feature',
-  branch: 'razvan.radulescu/feature',
-  path: 'PR-Overviews/PR-7.html',
-  authorEmail: 'Alice@Example.com',
-  authorName: 'Alice',
-};
-
-describe('PendingCommitsService.enqueueIfAbsent', () => {
-  it('inserts (canonical workspace id, lowercased email) when no row exists', async () => {
-    const { db, inserted } = makeFakeDb(0);
-    const svc = new PendingCommitsService(db);
-
-    await expect(svc.enqueueIfAbsent(INPUT)).resolves.toBe(true);
-
-    expect(inserted).toHaveLength(1);
-    expect(inserted[0]).toMatchObject({
-      // Same canonicalization as `enqueue` — the worker claims per the
-      // ENCODED `knownWorkspaces()` id, so a decoded id would never drain.
-      workspaceId: 'razvan.radulescu%2Ffeature',
-      branch: 'razvan.radulescu/feature',
-      path: 'PR-Overviews/PR-7.html',
-      authorEmail: 'alice@example.com',
-      authorName: 'Alice',
-    });
-  });
-
-  it('is a no-op when ANY row exists for the tuple (pending, running, or needs_attention)', async () => {
-    const { db, inserted } = makeFakeDb(1);
-    const svc = new PendingCommitsService(db);
-
-    await expect(svc.enqueueIfAbsent(INPUT)).resolves.toBe(false);
-    expect(inserted).toHaveLength(0);
-  });
-});
+import { describe, expect, it, vi } from 'vitest';
+import { PendingCommitsService } from '../pending-commits.service.js';
+import type { Database } from '../../database/connection.js';
+
+/**
+ * `enqueueIfAbsent` backs the pull-conflict recovery dispatch: it must
+ * insert only when NO row exists for the (workspace, branch, path) in ANY
+ * status. A plain `enqueue` would refresh an existing pending row and reset
+ * its retry counters — and the dispatch path fires on every sync attempt,
+ * so those resets would starve the worker's ladder and the recovery agent
+ * would never spawn. A `needs_attention` row must also block re-entry (the
+ * ladder already escalated to a human; more agent runs are just a loop).
+ *
+ * Fake drizzle chain, same shape as the vault tests — the queue's SQL-level
+ * behavior (claim fencing etc.) is covered elsewhere; this pins the
+ * check-then-insert decision logic.
+ */
+interface SelectChain extends PromiseLike<unknown> {
+  from: (...args: unknown[]) => SelectChain;
+  where: (...args: unknown[]) => SelectChain;
+}
+
+interface InsertChain extends PromiseLike<unknown> {
+  values: (...args: unknown[]) => InsertChain;
+}
+
+function makeFakeDb(existingCount: number) {
+  const inserted: unknown[] = [];
+  const selectChain: SelectChain = {
+    from: vi.fn(() => selectChain),
+    where: vi.fn(() => selectChain),
+    then: (onF, onR) => Promise.resolve([{ count: existingCount }]).then(onF, onR),
+  };
+  const insertChain: InsertChain = {
+    values: vi.fn((v: unknown) => {
+      inserted.push(v);
+      return insertChain;
+    }),
+    then: (onF, onR) => Promise.resolve(undefined).then(onF, onR),
+  };
+  const db = {
+    select: vi.fn(() => selectChain),
+    insert: vi.fn(() => insertChain),
+  } as unknown as Database;
+  return { db, inserted };
+}
+
+const INPUT = {
+  workspaceId: 'razvan.radulescu/feature',
+  branch: 'razvan.radulescu/feature',
+  path: 'PR-Overviews/PR-7.html',
+  authorEmail: 'Alice@Example.com',
+  authorName: 'Alice',
+};
+
+describe('PendingCommitsService.enqueueIfAbsent', () => {
+  it('inserts (canonical workspace id, lowercased email) when no row exists', async () => {
+    const { db, inserted } = makeFakeDb(0);
+    const svc = new PendingCommitsService(db);
+
+    await expect(svc.enqueueIfAbsent(INPUT)).resolves.toBe(true);
+
+    expect(inserted).toHaveLength(1);
+    expect(inserted[0]).toMatchObject({
+      // Same canonicalization as `enqueue` — the worker claims per the
+      // ENCODED `knownWorkspaces()` id, so a decoded id would never drain.
+      workspaceId: 'razvan.radulescu%2Ffeature',
+      branch: 'razvan.radulescu/feature',
+      path: 'PR-Overviews/PR-7.html',
+      authorEmail: 'alice@example.com',
+      authorName: 'Alice',
+    });
+  });
+
+  it('is a no-op when ANY row exists for the tuple (pending, running, or needs_attention)', async () => {
+    const { db, inserted } = makeFakeDb(1);
+    const svc = new PendingCommitsService(db);
+
+    await expect(svc.enqueueIfAbsent(INPUT)).resolves.toBe(false);
+    expect(inserted).toHaveLength(0);
+  });
+});

package/src/modules/workflow/__tests__/workflow.service.facade.test.ts

@@ -12,6 +12,7 @@ import type { IAccessControl } from '../../access/access-control.interface.js';
 import { FileLockService } from '../file-lock.service.js';
 import { PendingCommitsService } from '../pending-commits.service.js';
 import { WorkflowService } from '../workflow.service.js';
+import { PullRebaseConflictError } from '../workflow.errors.js';
 import type { Database } from '../../database/connection.js';
 
 // The facade tests never exercise `openChangeRequest` (the only method that
@@ -50,6 +51,7 @@ function makePendingCommits(): PendingCommitsService {
   // behavior is covered by `pending-commits.service.test.ts`.
   return {
     enqueue: vi.fn().mockResolvedValue(undefined),
+    enqueueIfAbsent: vi.fn().mockResolvedValue(true),
     claimNext: vi.fn().mockResolvedValue(null),
     markSucceeded: vi.fn().mockResolvedValue(undefined),
     markTransientFailure: vi.fn().mockResolvedValue(undefined),
@@ -327,6 +329,48 @@ describe('WorkflowService — change request delegation + cache invalidation', (
     );
     expect(prs.invalidateDetailCache).toHaveBeenCalledWith(4);
   });
+
+  it('mergeChangeRequest still merges when the post-merge pull conflicts, and queues recovery on the TARGET workspace', async () => {
+    const prs = makePrs();
+    const reviewWorkflow = makeReviewWorkflow();
+    const mergeResult = { prNumber: 4, sha: 'abc', mergedAt: 't' };
+    (reviewWorkflow.mergePr as ReturnType<typeof vi.fn>).mockResolvedValue(mergeResult);
+    (prs.getPr as ReturnType<typeof vi.fn>).mockResolvedValue({ branch: 'alice/feat', base: 'main' });
+
+    const git = makeGit();
+    const conflict = new PullRebaseConflictError(
+      'main',
+      // Deliberately unsorted — the representative row must be the smallest.
+      ['b-second.md', 'a-first.md'],
+      'git rebase failed: could not apply deadbee',
+    );
+    (git.pull as ReturnType<typeof vi.fn>).mockRejectedValue(conflict);
+    const workspaceService = makeWorkspaceService();
+    // Return an id that ISN'T derivable from the branch name, pinning that
+    // the dispatch uses the id `getOrCreateForBranch` returned rather than
+    // re-deriving it.
+    (workspaceService.getOrCreateForBranch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      id: 'resolved-target-ws',
+    });
+    const pending = makePendingCommits();
+    const svc = new WorkflowService(makeDb(), git, prs, reviewWorkflow, workspaceService, makeAccessControl(), makeFileLockService(), pending, 'knowledge-base');
+
+    const outcome = await svc.mergeChangeRequest(
+      4, makeUser(), 'sha', [], 'open', 'PR title', 'main', 'w1', { bypass: true },
+    );
+
+    // The merge already landed on origin — a stuck target workspace must not
+    // fail the response.
+    expect(outcome).toEqual({ kind: 'merged', result: mergeResult });
+    expect(pending.enqueueIfAbsent).toHaveBeenCalledTimes(1);
+    expect(pending.enqueueIfAbsent).toHaveBeenCalledWith({
+      workspaceId: 'resolved-target-ws',
+      branch: 'main',
+      path: 'a-first.md',
+      authorEmail: 'alice@example.com',
+      authorName: 'Alice',
+    });
+  });
 });
 
 describe('WorkflowService — file lock delegation', () => {