@bevel-software/platform-core-backend 0.25.2 → 0.27.0

package/src/modules/workflow/agent-tools/__tests__/workflow.tools.test.ts

@@ -9,7 +9,13 @@ import { createToolContextResolver } from '../../../tool-helpers/tool-context.js
 import { createToolHandlerFactory } from '../../../tool-helpers/tool-handler.js';
 import { createManualRoutes } from '../../../tool-registry/manual.routes.js';
 import { registerWorkflowTools } from '../workflow.tools.js';
-import { ChangeRequestConflictsError, OpenChangeRequestBlocksMergeError } from '../../../../shared/domain-errors.js';
+import {
+  BranchAuthorshipError,
+  BranchDeleteBlockedError,
+  BranchNotFoundError,
+  ChangeRequestConflictsError,
+  OpenChangeRequestBlocksMergeError,
+} from '../../../../shared/domain-errors.js';
 
 const WS = 'target-company-state';
 
@@ -85,6 +91,9 @@ const externalApiKeyService = {
     t === 'bevel_key' ? { user: { id: 'user-A', email: 'e@x', name: 'N' }, tokenId: 'tok' } : null,
 } as never;
 const authService = { getUserById: async (id: string) => ({ id, email: 'e@x', name: 'N' }) } as never;
+/** A declined change request: no sha records what it proposed, so it has no head. */
+const DECLINED_CR = 21;
+
 const workspaceService = {
   getOrCreateForUser: async () => ({ id: WS }),
   getWorkspacePath: async () => '/tmp/ws',
@@ -117,12 +126,15 @@ const workflowService = {
   releaseLock: async (ws: string, branch: string, path: string) => {
     calls.push(['releaseLock', ws, branch, path]);
   },
+  // #21 is DECLINED: the service reads such a row from nothing (no sha records
+  // what it proposed), so its detail carries no head — which is what the comment
+  // tool has to anchor to. Every other number is an ordinary open request.
   getChangeRequestDetail: async (number: number) => ({
     number,
     url: `https://bevel.example.com/change-requests/${number}`,
-    headSha: 'head-1',
+    headSha: number === DECLINED_CR ? '' : 'head-1',
     approvals: [],
-    state: 'open',
+    state: number === DECLINED_CR ? 'closed' : 'open',
     title: 'T',
     base: 'main',
   }),
@@ -138,6 +150,34 @@ const workflowService = {
     }
     return { kind: 'merged', sha: 'merge-sha' };
   },
+  deleteBranchChecked: async (
+    user: { id: string },
+    name: string,
+    { maySee, ...opts }: { dryRun?: boolean; discardUnmerged?: boolean; maySee?: (n: number) => Promise<boolean> },
+  ) => {
+    calls.push(['deleteBranchChecked', user.id, name, opts]);
+    if (maySee) calls.push(['maySee', 12, await maySee(12)], ['maySee', 13, await maySee(13)]);
+    if (name === 'me/missing') throw new BranchNotFoundError(name);
+    if (name === 'ali/theirs') throw new BranchAuthorshipError(name);
+    if (name === 'me/proposed') {
+      throw new BranchDeleteBlockedError(
+        'open-change-request',
+        name,
+        'Change request #12 is open from "me/proposed". Ask the user to withdraw or decline it in the app; then the branch can be deleted.',
+        { number: 12 },
+      );
+    }
+    if (name === 'me/unmerged' && !(opts as { discardUnmerged?: boolean }).discardUnmerged) {
+      throw new BranchDeleteBlockedError('unmerged-commits', name, '"me/unmerged" holds 3 commits…', { unmergedCommits: 3 });
+    }
+    if (name === 'me/offline') {
+      throw new BranchDeleteBlockedError('state-unconfirmed', name, 'Could not reach the shared repository…');
+    }
+    if ((opts as { dryRun?: boolean }).dryRun) {
+      return { kind: 'preview', branch: name, exists: true, canDelete: true, refusals: [], unmergedCommits: 0, openChangeRequests: [], lastCommit: 'tip-1' };
+    }
+    return { kind: 'deleted', branch: name, lastCommit: 'tip-1', discardedCommits: name === 'me/unmerged' ? 3 : 0 };
+  },
   postComment: async (number: number, _user: unknown, input: { path?: string }) => {
     calls.push(['postComment', number, input.path]);
     return { id: 'c-1' };
@@ -163,7 +203,11 @@ async function start(): Promise<string> {
   const toolHandler = createToolHandlerFactory(resolve);
 
   const router = express.Router();
-  registerWorkflowTools(registry, router, toolAuth, toolHandler, testKbContext());
+  // Request #13 is one the caller may not see.
+  registerWorkflowTools(registry, router, toolAuth, toolHandler, testKbContext(), async (ctx, number) => {
+    calls.push(['maySeeAs', ctx.user.id, number]);
+    return number !== 13;
+  });
   router.use(createManualRoutes(registry, toolAuth));
 
   const app = express();
@@ -229,6 +273,95 @@ describe('registerWorkflowTools', () => {
     expect(commentBody.changeRequest).not.toHaveProperty('urlNote');
   });
 
+  // A comment anchors to a commit. A declined request records none — nothing
+  // durable says what it proposed, so it is read from nothing and its detail
+  // carries no head. Say so, rather than letting the service's `head sha is
+  // required` come back as a 400 about an argument the caller never passed.
+  it('post_change_request_comment says why a declined request takes no comment', async () => {
+    const base = await start();
+    const res = await post(`${base}/api/agent/tools/post_change_request_comment`, writeTok(), { number: DECLINED_CR, body: 'why was this turned down?' });
+    expect(res.status).toBe(409);
+    expect(((await res.json()) as { error: string }).error).toMatch(
+      new RegExp(`#${DECLINED_CR} is closed and has no commit to anchor a comment to`),
+    );
+    // Nothing was written: the refusal happens before the service is asked.
+    expect(calls.some((c) => c[0] === 'postComment')).toBe(false);
+  });
+
+  describe('delete_branch', () => {
+    it('is on both catalogs, takes name, dryRun and discardUnmerged, and is a write tool', async () => {
+      await start();
+      for (const tools of [await registryRef!.listInternal(), await registryRef!.listExternal()]) {
+        const tool = tools.find((t) => t.name === 'delete_branch');
+        expect(tool).toBeDefined();
+        // `toolDef` wraps a tool's own inputs under `body`.
+        const inputs = (tool!.inputs as { properties: { body: { properties: Record<string, unknown>; required: string[] } } })
+          .properties.body;
+        expect(Object.keys(inputs.properties).sort()).toEqual(['discardUnmerged', 'dryRun', 'name']);
+        expect(inputs.required).toEqual(['name']);
+        expect(tool!.tags).toContain('write');
+        // An empty request is closed by the delete; a live one refuses it, linked.
+        expect(tool!.description).toContain('proposes nothing is closed');
+        expect(tool!.description).toContain('its author withdraws it or an Admin declines it');
+      }
+    });
+
+    it('deletes as the caller and answers the last commit', async () => {
+      const base = await start();
+      const res = await post(`${base}/api/agent/tools/delete_branch`, writeTok(), { name: 'me/draft' });
+      expect(res.status).toBe(200);
+      expect(await res.json()).toEqual({ kind: 'deleted', branch: 'me/draft', lastCommit: 'tip-1', discardedCommits: 0 });
+      expect(calls).toContainEqual(['deleteBranchChecked', 'user-A', 'me/draft', { dryRun: false, discardUnmerged: false }]);
+    });
+
+    it('passes dryRun and discardUnmerged through', async () => {
+      const base = await start();
+      const preview = await post(`${base}/api/agent/tools/delete_branch`, writeTok(), { name: 'me/draft', dryRun: true });
+      expect(await preview.json()).toMatchObject({ kind: 'preview', canDelete: true, lastCommit: 'tip-1' });
+      const discarded = await post(`${base}/api/agent/tools/delete_branch`, writeTok(), { name: 'me/unmerged', discardUnmerged: true });
+      expect(await discarded.json()).toMatchObject({ kind: 'deleted', discardedCommits: 3 });
+      expect(calls).toContainEqual(['deleteBranchChecked', 'user-A', 'me/draft', { dryRun: true, discardUnmerged: false }]);
+      expect(calls).toContainEqual(['deleteBranchChecked', 'user-A', 'me/unmerged', { dryRun: false, discardUnmerged: true }]);
+    });
+
+    it('answers each refusal with its status and message', async () => {
+      const base = await start();
+      const ask = async (name: string) => {
+        const res = await post(`${base}/api/agent/tools/delete_branch`, writeTok(), { name });
+        return { status: res.status, body: (await res.json()) as Record<string, unknown> };
+      };
+      const missing = await ask('me/missing');
+      expect(missing.status).toBe(404);
+      expect(missing.body.error).toMatch(/no branch named me\/missing/);
+      const theirs = await ask('ali/theirs');
+      expect(theirs.status).toBe(403);
+      expect(theirs.body.error).toBe('Only the author of "ali/theirs" can delete it.');
+      const proposed = await ask('me/proposed');
+      expect(proposed.status).toBe(409);
+      expect(proposed.body).toMatchObject({ reason: 'open-change-request', number: 12 });
+      expect(proposed.body.error).toMatch(/#12.*withdraw or decline it in the app/);
+      const unmerged = await ask('me/unmerged');
+      expect(unmerged.status).toBe(409);
+      expect(unmerged.body).toMatchObject({ reason: 'unmerged-commits', unmergedCommits: 3 });
+      expect((await ask('me/offline')).status).toBe(503);
+    });
+
+    it('requires a name', async () => {
+      const base = await start();
+      const res = await post(`${base}/api/agent/tools/delete_branch`, writeTok(), {});
+      expect(res.status).toBe(400);
+      expect(calls.some((c) => c[0] === 'deleteBranchChecked')).toBe(false);
+    });
+
+    it("hands the service the caller's view of change requests, as get_change_request gates it", async () => {
+      const base = await start();
+      await post(`${base}/api/agent/tools/delete_branch`, writeTok(), { name: 'me/draft', dryRun: true });
+      expect(calls).toContainEqual(['maySeeAs', 'user-A', 12]);
+      expect(calls).toContainEqual(['maySee', 12, true]);
+      expect(calls).toContainEqual(['maySee', 13, false]);
+    });
+  });
+
   // An agent proposes and syncs; a person merges.
   describe('merging', () => {
     it('merge_change_request is gone: its old path answers who merges now, and never merges', async () => {
@@ -283,6 +416,19 @@ describe('registerWorkflowTools', () => {
         const mergeBranch = tools.find((t) => t.name === 'merge_branch')!;
         expect(mergeBranch.description).toMatch(/a person merges/);
         expect(mergeBranch.description).toMatch(/SYNC/);
+        // Every outcome is named, and the asynchronous commit the merge waits for.
+        for (const kind of ['merged', 'nothing-to-merge', 'pending-commits', 'conflicts-need-resolution']) {
+          expect(mergeBranch.description, kind).toContain(`\`${kind}\``);
+        }
+        expect(mergeBranch.description).toMatch(/committed asynchronously/);
+        expect(mergeBranch.description).toMatch(/waits up to 20s/);
+        const outcome = (mergeBranch.outputs as { properties: { outcome: { description: string; properties: Record<string, { enum?: string[] }> } } })
+          .properties.outcome;
+        expect(outcome.properties.kind.enum).toEqual(['merged', 'nothing-to-merge', 'pending-commits', 'conflicts-need-resolution']);
+        expect(Object.keys(outcome.properties)).toEqual(
+          expect.arrayContaining(['sha', 'conflictedPaths', 'branch', 'pending', 'needsAttention', 'message']),
+        );
+        expect(outcome.description).toMatch(/committed asynchronously and the merge waits/);
       }
     });
   });