wip v28

Author: geraldarthurdavis

packages/generic-tools/vcs/__tests__/createOrUpdateFileTool.test.ts

@@ -1,4 +1,4 @@
-import { createOrUpdateFileTool } from '../src/index';
+import { createBranchTool, createOrUpdateFileTool } from '../src/index';
 
 jest.mock('@bitcode/generic-tools-editing/execution-context', () => ({
   executionContext: {
@@ -14,23 +14,27 @@ jest.mock('@bitcode/supabase/ssr/server', () => ({
   createClient: jest.fn().mockResolvedValue({}),
 }));
 
-const mockConnectionManager = {
+let mockConnectionManager: any;
+let mockProvider: any;
+
+jest.mock('@bitcode/vcs', () => ({
+  VCSConnections: jest.fn().mockImplementation(() => mockConnectionManager),
+  VCSProviderFactory: {
+    create: jest.fn().mockImplementation(async () => mockProvider),
+  },
+}));
+
+mockConnectionManager = {
   getConnectionById: jest.fn(),
   getConnection: jest.fn(),
   getAuthFromConnection: jest.fn(),
 };
 
-const mockProvider = {
+mockProvider = {
+  createBranch: jest.fn(),
   createOrUpdateFile: jest.fn(),
 };
 
-jest.mock('@bitcode/vcs', () => ({
-  VCSConnections: jest.fn().mockImplementation(() => mockConnectionManager),
-  VCSProviderFactory: {
-    create: jest.fn().mockResolvedValue(mockProvider),
-  },
-}));
-
 const { executionContext } = require('@bitcode/generic-tools-editing/execution-context');
 const { validateFileOperation } = require('@bitcode/pipelines-generics/src/gate-system/file-gates');
 const { VCSConnections, VCSProviderFactory } = require('@bitcode/vcs');
@@ -46,10 +50,13 @@ const baseInput = {
 
 describe('createOrUpdateFileTool gating', () => {
   beforeEach(() => {
-    jest.resetAllMocks();
+    jest.clearAllMocks();
+    (VCSConnections as jest.Mock).mockImplementation(() => mockConnectionManager);
+    (VCSProviderFactory.create as jest.Mock).mockResolvedValue(mockProvider);
     mockConnectionManager.getConnectionById.mockResolvedValue({ id: 'conn-1' });
     mockConnectionManager.getConnection.mockResolvedValue({ id: 'conn-1' });
     mockConnectionManager.getAuthFromConnection.mockResolvedValue({ token: 'abc' });
+    mockProvider.createBranch.mockResolvedValue({ name: 'feature/asset-pack' });
     mockProvider.createOrUpdateFile.mockResolvedValue({ ok: true });
     (executionContext.getStore as jest.Mock).mockReturnValue({
       get: (namespace: string, key: string) => {
@@ -87,7 +94,10 @@ describe('createOrUpdateFileTool gating', () => {
       baseInput.owner,
       baseInput.repo,
       baseInput.path,
-      expect.objectContaining({ message: baseInput.message })
+      expect.objectContaining({
+        content: baseInput.content,
+        message: baseInput.message,
+      })
     );
   });
 
@@ -101,4 +111,23 @@ describe('createOrUpdateFileTool gating', () => {
     expect(VCSProviderFactory.create).toHaveBeenCalled();
     expect(mockProvider.createOrUpdateFile).toHaveBeenCalled();
   });
+
+  it('creates branches through the VCS provider boundary', async () => {
+    await createBranchTool.use({
+      provider: 'github',
+      owner: 'bitcode-labs',
+      repo: 'repo',
+      connectionId: 'conn-1',
+      branch: 'feature/asset-pack',
+      from: 'abc123',
+    });
+
+    expect(mockProvider.createBranch).toHaveBeenCalledWith(
+      expect.any(Object),
+      'bitcode-labs',
+      'repo',
+      'feature/asset-pack',
+      'abc123'
+    );
+  });
 });

packages/generic-tools/vcs/jest.config.cjs

@@ -0,0 +1,27 @@
+module.exports = {
+  preset: 'ts-jest/presets/js-with-ts',
+  testEnvironment: 'node',
+  testMatch: ['**/__tests__/**/*.test.(ts|tsx)'],
+  testPathIgnorePatterns: ['/node_modules/', '/dist/'],
+  roots: ['<rootDir>'],
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  globals: {
+    'ts-jest': {
+      tsconfig: '<rootDir>/tsconfig.json',
+      diagnostics: false,
+    },
+  },
+  moduleNameMapper: {
+    '^@bitcode/generic-tools-editing/execution-context$':
+      '<rootDir>/../files-maintaining/src/execution-context.ts',
+    '^@bitcode/tools-generics$': '<rootDir>/../../tools-generics/src/index.ts',
+    '^@bitcode/tools-generics/(.*)$': '<rootDir>/../../tools-generics/src/$1',
+    '^@bitcode/pipelines-generics$': '<rootDir>/../../pipelines-generics/src/index.ts',
+    '^@bitcode/pipelines-generics/(.*)$': '<rootDir>/../../pipelines-generics/$1',
+    '^@bitcode/vcs$': '<rootDir>/../../vcs/src/index.ts',
+    '^@bitcode/vcs/(.*)$': '<rootDir>/../../vcs/src/$1',
+    '^@bitcode/supabase$': '<rootDir>/../../supabase/src/index.ts',
+    '^@bitcode/supabase/(.*)$': '<rootDir>/../../supabase/src/$1',
+    '^@bitcode/errors$': '<rootDir>/../../errors/src/index.ts',
+  },
+};

packages/generic-tools/vcs/package.json

@@ -7,6 +7,7 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
+    "test": "pnpm exec jest --config jest.config.cjs --passWithNoTests",
     "typecheck": "tsc -p tsconfig.typecheck.json --noEmit"
   },
   "dependencies": {
@@ -17,7 +18,10 @@
     "zod": "^3.21.4"
   },
   "devDependencies": {
+    "@types/jest": "^29.5.12",
     "@types/node": "^20.0.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
     "typescript": "^5.0.0"
   }
 }

packages/generic-tools/vcs/src/index.ts

@@ -251,6 +251,39 @@ class CreatePullRequestTool extends Tool<any> {
 
 export const createPullRequestTool = new CreatePullRequestTool();
 
+class CreateBranchTool extends Tool<any> {
+  name = 'vcs_create_branch';
+  description = 'Create a branch in a repository through unified VCS interface';
+
+  inputSchema = vcsBaseSchema.extend({
+    branch: z.string().describe('Branch name to create'),
+    from: z.string().describe('Base branch or commit SHA for the new branch'),
+  });
+
+  use = async (input: z.infer<typeof this.inputSchema>) => {
+    const { auth, instanceUrl } = await resolveConnectionContext(input);
+    const vcsProvider = await createProvider(input.provider, instanceUrl);
+
+    if (!vcsProvider.createBranch) {
+      throw new Error(`Branch creation not supported by ${input.provider}`);
+    }
+
+    return withRetry(
+      () => vcsProvider.createBranch!(auth, input.owner, input.repo, input.branch, input.from),
+      {
+        maxAttempts: 3,
+        delayMs: 1000,
+        shouldRetry: (error) => {
+          const message = error.message.toLowerCase();
+          return message.includes('network') || message.includes('timeout');
+        },
+      }
+    );
+  };
+}
+
+export const createBranchTool = new CreateBranchTool();
+
 /**
  * @doc-code-tool
  * @prompt CREATE_OR_UPDATE_FILE_DOC_CODE_TOOL_PROMPT
@@ -275,7 +308,7 @@ class CreateOrUpdateFileTool extends Tool<any> {
 
     return withRetry(
       () => vcsProvider.createOrUpdateFile(auth, input.owner, input.repo, input.path, {
-        content: Buffer.from(input.content).toString('base64'),
+        content: input.content,
         message: input.message,
         branch: input.branch,
         sha: input.sha
@@ -424,6 +457,7 @@ export const getFileContentTool = new GetFileContentTool();
  */
 export const vcsTools = [
   listRepositoriesTool,
+  createBranchTool,
   createPullRequestTool,
   createOrUpdateFileTool,
   createIssueTool,

packages/github/src/providers/github-provider.ts

@@ -451,6 +451,43 @@ export default class GitHubProvider extends VCSProvider {
     });
   }
 
+  /**
+   * Create branch
+   */
+  async createBranch(
+    auth: VCSAuth,
+    owner: string,
+    repo: string,
+    branch: string,
+    from: string
+  ): Promise<VCSBranch> {
+    return this.executeWithResilience(async () => {
+      const octokit = this.getOctokit(auth);
+      const ref = branch.startsWith('refs/heads/') ? branch : `refs/heads/${branch}`;
+      const branchName = ref.replace(/^refs\/heads\//, '');
+
+      try {
+        await octokit.git.createRef({
+          owner,
+          repo,
+          ref,
+          sha: from,
+        });
+      } catch (error) {
+        const status = (error as { status?: number })?.status;
+        const message = error instanceof Error ? error.message.toLowerCase() : '';
+        if (status !== 422 && !message.includes('reference already exists')) {
+          throw error;
+        }
+      }
+
+      return this.getBranch(auth, owner, repo, branchName);
+    }, {
+      operationName: 'createBranch',
+      timeout: this.timeouts.write
+    });
+  }
+
   /**
    * List commits
    */

packages/pipeline-hosts/src/asset-pack-harness.ts

@@ -396,6 +396,26 @@ function normalizeResultState(candidate) {
     : 'blocked_readiness';
 }
 
+function requiresPullRequestDelivery(output, input) {
+  const template =
+    output?.deliveryMechanismTemplate ||
+    output?.assetPack?.deliveryMechanismTemplate ||
+    input?.deliveryMechanismTemplate;
+  return template === 'pull-request';
+}
+
+function findPullRequestUrl(output) {
+  return (
+    output?.deliveryMechanism?.pullRequest?.url ||
+    output?.deliveryMechanism?.prUrl ||
+    output?.shippables?.pullRequest?.url ||
+    output?.shippable?.prUrl ||
+    output?.writtenAssets?.pullRequest?.url ||
+    output?.assetPackSynthesisArtifacts?.pullRequest?.url ||
+    null
+  );
+}
+
 function isUsableUuid(value) {
   return UUID_PATTERN.test(String(value || '')) && value !== DEFAULT_USER_ID;
 }
@@ -1489,6 +1509,9 @@ try {
 
   execution.store('harness', 'manifestRoot', manifestRoot);
   execution.store('harness', 'sourceRevision', manifest.sourceRevision);
+  execution.store('harness', 'runId', runId);
+  execution.store('harness', 'userId', userId);
+  execution.store('pipeline', 'userId', userId);
   execution.store('read', 'request', manifest.read);
   execution.store('deposit', 'reference', manifest.deposit);
 
@@ -1497,6 +1520,8 @@ try {
     const { supabaseAdmin } = await import('../../packages/supabase/src/index');
     supabase = supabaseAdmin;
     userId = await resolvePipelineUserId();
+    execution.store('harness', 'userId', userId);
+    execution.store('pipeline', 'userId', userId);
     pipelineRunId = await insertPipelineRun();
     record({ type: 'database-streaming-enabled', stage: 'telemetry-readback' });
   }
@@ -1551,7 +1576,14 @@ try {
   const pipelineResultState = normalizeResultState(
     output?.resultState || output?.fitResult?.resultState || output?.fit?.resultState
   );
-  resultState = manifest.sourceOverlay ? 'blocked_readiness' : pipelineResultState;
+  const deliveryRequired = requiresPullRequestDelivery(output, input);
+  const pullRequestUrl = findPullRequestUrl(output);
+  const deliveryAdmissible = !deliveryRequired || Boolean(pullRequestUrl);
+  const settlementResultState =
+    pipelineResultState === 'worthy_fit' && !deliveryAdmissible
+      ? 'blocked_readiness'
+      : pipelineResultState;
+  resultState = manifest.sourceOverlay ? 'blocked_readiness' : settlementResultState;
   const fitResult = output?.fitResult || output?.fit || null;
   const depositorySearch = output?.depositorySearch || null;
   const pipelineResultReasons = Array.isArray(fitResult?.resultReasons)
@@ -1570,13 +1602,22 @@ try {
       : null,
     pipelineResultState === 'blocked_readiness'
       ? 'Pipeline output did not include an admissible result state; review remains blocked.'
+      : pipelineResultState === 'worthy_fit' && !deliveryAdmissible
+        ? 'Pipeline found a worthy fit, but required pull-request delivery is missing; settlement remains blocked.'
       : resultState === 'blocked_readiness'
         ? 'Pipeline produced ' + pipelineResultState + ' evidence; final settlement remains blocked by harness readiness constraints.'
       : 'Review SQL must still verify durable telemetry, proof, and ledger readback before settlement.',
     ...pipelineResultReasons,
   ].filter(Boolean);
+  record({
+    type: 'delivery-readback',
+    stage: 'finish',
+    required: deliveryRequired,
+    admissible: deliveryAdmissible,
+    pullRequestUrl: pullRequestUrl || null,
+  });
 
-  const ledgerSettlement = await settleAssetPackLedger(pipelineResultState);
+  const ledgerSettlement = await settleAssetPackLedger(settlementResultState);
   output = {
     ...(output || {}),
     ledgerSettlement,

packages/pipelines/asset-pack/package.json

@@ -31,6 +31,7 @@
     "@bitcode/registry": "workspace:*",
     "@bitcode/supabase": "workspace:*",
     "@bitcode/tools-generics": "workspace:*",
+    "@bitcode/vcs-tools": "workspace:*",
     "openai": "^4.0.0",
     "zod": "^3.22.4"
   },

packages/pipelines/asset-pack/src/__tests__/finish-completion.test.ts

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { Execution } from '@bitcode/execution-generics';
+import AssetPackCompletionAgent from '../agents/finish/asset-pack-completion-agent';
+
+describe('finish AssetPack completion evidence', () => {
+  it('builds repository and pull-request headers from source-bound finish evidence', async () => {
+    const exec = new Execution('pipeline:asset-pack');
+    exec.store('pipeline', 'expressedRead', 'Read the deposited source and ship the Fit result.');
+    exec.store('pipeline', 'writtenAssetType', 'read-satisfaction-asset-pack');
+    exec.store('harness', 'sourceRevision', {
+      repositoryFullName: 'engineeredsoftware/ENGI',
+      branch: 'main',
+      commit: '272b5b1586b28363b57676603a1990bb10df319c',
+    });
+    exec.store('finish', 'deliveryReadiness', {
+      status: 'delivered',
+      branch: 'bitcode/asset-pack-run-123',
+      path: '.bitcode/asset-packs/run-123.md',
+      prUrl: 'https://github.com/engineeredsoftware/ENGI/pull/123',
+    });
+    exec.store('finish', 'pullRequestUrl', 'https://github.com/engineeredsoftware/ENGI/pull/123');
+    exec.store('finish', 'pullRequestNumber', 123);
+    exec.store('finish', 'pullRequestTitle', 'Bitcode AssetPack delivery run-123');
+
+    const result = await AssetPackCompletionAgent({}, exec);
+
+    expect(result.repoSnapshot).toEqual({
+      org: 'engineeredsoftware',
+      repo: 'ENGI',
+      branch: 'main',
+      commit: '272b5b1586b28363b57676603a1990bb10df319c',
+    });
+    expect(result.shippables.pullRequest).toMatchObject({
+      url: 'https://github.com/engineeredsoftware/ENGI/pull/123',
+      number: 123,
+    });
+    expect(result.deliveryMechanism?.readiness).toMatchObject({
+      status: 'delivered',
+      branch: 'bitcode/asset-pack-run-123',
+    });
+    expect(result.deliveryMechanism?.summary).toContain('engineeredsoftware/ENGI');
+  });
+});