forge-workflow 0.1.0-beta.6 → 0.1.0-beta.8

package/lib/kernel/migrations.js

@@ -1,5 +1,5 @@
 const { getKernelSchema, validateKernelSchema } = require('./schema');
-const { USAGE_EVIDENCE_MIGRATION } = require('../../packages/memory');
+const { USAGE_EVIDENCE_MIGRATION } = require('@forge/memory');
 
 function assertIdentifier(identifier, label) {
 	if (!/^[a-z][a-z0-9_]*$/.test(identifier)) {

package/lib/kernel/sqlite-driver.js

@@ -30,7 +30,7 @@ const {
 const { CONFLICT_SIGNAL, classifyConflictSignal } = require('./conflict-signal');
 const { normalizeRecallHit } = require('../memory-recall');
 const { getPackageRoot } = require('../package-root');
-const { appendUsageEvidence, rebuildUsageProjection } = require('../../packages/memory');
+const { appendUsageEvidence, rebuildUsageProjection } = require('@forge/memory');
 
 const BUILTIN_SQLITE_RUNTIME_ORDER = Object.freeze(['bun:sqlite', 'node:sqlite']);
 let probeCounter = 0;

package/lib/memory/router.js

@@ -32,7 +32,7 @@ const projectMemory = require('../project-memory');
 const {
   assertBackend,
   createMemoryBackendRegistry,
-} = require('../../packages/memory');
+} = require('@forge/memory');
 
 /** Supported PUBLIC backends, default first. */
 const MEMORY_BACKENDS = ['local', 'graphiti'];

package/lib/memory/usage-evidence.js

@@ -1,4 +1,4 @@
 'use strict';
 
 // Compatibility shim: the durable usage contract belongs to @forge/memory.
-module.exports = require('../../packages/memory');
+module.exports = require('@forge/memory');

package/lib/native-gh.js

@@ -0,0 +1,177 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { spawnSync } = require('node:child_process');
+const { isCompiledBinary } = require('./package-root');
+
+const ROUTER_MARKER = 'forge-gh-router-v1';
+const LOCAL_COMMANDS = new Set([
+  'accessibility', 'actions', 'alias', 'auth', 'completion', 'config', 'environment', 'exit-codes', 'formatting',
+  'help', 'licenses', 'mintty', 'preview', 'reference', 'telemetry', 'version',
+]);
+const HELP_COMMANDS = new Set([
+  'agent-task', 'api', 'attestation', 'browse', 'cache', 'co', 'codespace', 'copilot', 'discussion', 'extension',
+  'gist', 'gpg-key', 'issue', 'label', 'org', 'pr', 'project', 'release', 'repo', 'ruleset', 'run', 'search',
+  'secret', 'skill', 'skills', 'ssh-key', 'status', 'variable', 'workflow',
+]);
+const GLOBAL_VALUE_FLAGS = new Set(['--hostname', '--repo', '-R']);
+const SKILL_VALUE_FLAGS = new Set(['--agent', '--dir', '--pin', '--scope']);
+const TRUE_BOOLEAN_VALUES = new Set(['1', 't', 'T', 'TRUE', 'true', 'True']);
+
+function environmentValue(environment, name) {
+  const key = Object.keys(environment).find(candidate => candidate.toUpperCase() === name);
+  return key ? environment[key] : undefined;
+}
+
+function withoutProxyMarker(environment) {
+  return Object.fromEntries(Object.entries(environment).filter(([key]) => key.toUpperCase() !== 'FORGE_GH_PROXY_ACTIVE'));
+}
+
+function commandName(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (GLOBAL_VALUE_FLAGS.has(arg)) { index += 1; continue; }
+    if (!arg.startsWith('-')) return arg;
+  }
+  return null;
+}
+
+function enabledBooleanFlag(argument, name) {
+  return argument === name || (argument.startsWith(`${name}=`)
+    && TRUE_BOOLEAN_VALUES.has(argument.slice(name.length + 1)));
+}
+
+function shortOptionValue(arg, resolveOptionValue) {
+  for (let offset = 1; offset < arg.length; offset += 1) {
+    const flag = `-${arg[offset]}`;
+    const takesValue = resolveOptionValue(flag);
+    if (typeof takesValue !== 'boolean') throw new Error(`Unable to determine GitHub CLI option arity for ${flag}.`);
+    if (takesValue) return { flag, attached: arg.slice(offset + 1).replace(/^=/, '') };
+  }
+  return null;
+}
+
+function isLocalSkillInvocation(args, command) {
+  const commandIndex = args.indexOf(command);
+  const subcommand = args[commandIndex + 1];
+  if (subcommand === 'list') return true;
+  if (!['install', 'add'].includes(subcommand)) return false;
+  let local = false;
+  for (let index = commandIndex + 2; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--') return false;
+    if (SKILL_VALUE_FLAGS.has(arg)) { index += 1; continue; }
+    if (enabledBooleanFlag(arg, '--upstream')) return false;
+    if (enabledBooleanFlag(arg, '--from-local')) local = true;
+  }
+  return local;
+}
+
+function isLocalExtensionInvocation(args, command) {
+  const commandIndex = args.indexOf(command);
+  if (args[commandIndex + 1] !== 'install') return false;
+  const values = [];
+  for (let index = commandIndex + 2; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--') return false;
+    if (arg === '--pin') { index += 1; continue; }
+    if (arg === '--force' || arg.startsWith('--force=') || arg.startsWith('--pin=')) continue;
+    if (arg.startsWith('-')) return false;
+    values.push(arg);
+  }
+  return values.length === 1 && values[0] === '.';
+}
+
+function isLocalGhInvocation(args, resolveOptionValue = () => null) {
+  if (args.length === 0) return true;
+  const command = commandName(args);
+  if (LOCAL_COMMANDS.has(command)) return true;
+  if (['skill', 'skills'].includes(command) && isLocalSkillInvocation(args, command)) return true;
+  if (command === 'extension' && isLocalExtensionInvocation(args, command)) return true;
+  const help = argument => {
+    if (enabledBooleanFlag(argument, '--help')) return true;
+    if (!enabledBooleanFlag(argument, '-h')) return false;
+    try { return resolveOptionValue('-h') === false; } catch { return false; }
+  };
+  if (args.length === 1) return enabledBooleanFlag(args[0], '--help') || enabledBooleanFlag(args[0], '-h')
+    || enabledBooleanFlag(args[0], '--version');
+  const delimiter = args.indexOf('--');
+  const end = delimiter < 0 ? args.length : delimiter;
+  if (!HELP_COMMANDS.has(command) || !args.slice(0, end).some(help)) return false;
+  for (let index = 0; index < end; index += 1) {
+    const arg = args[index];
+    if (help(arg)) return true;
+    if (!arg.startsWith('-') || arg.includes('=')) continue;
+    try {
+      if (arg.startsWith('--')) {
+        const takesValue = GLOBAL_VALUE_FLAGS.has(arg) || resolveOptionValue(arg);
+        if (typeof takesValue !== 'boolean') return false;
+        if (takesValue) index += 1;
+      } else {
+        const option = shortOptionValue(arg, resolveOptionValue);
+        if (option && !option.attached) index += 1;
+      }
+    } catch { return false; }
+  }
+  return false;
+}
+
+function exitCode(result) {
+  if (result?.error?.code === 'ENOENT') return 127;
+  if (result?.error?.code === 'EACCES') return 126;
+  if (Number.isInteger(result?.status)) return result.status;
+  return result?.signal && os.constants.signals[result.signal] ? 128 + os.constants.signals[result.signal] : 1;
+}
+
+function isForgeProxy(candidate, ownPath) {
+  const candidatePath = fs.realpathSync(candidate);
+  try {
+    if (candidatePath === fs.realpathSync(ownPath)) return true;
+  } catch { /* compiled Bun entrypoints may not exist on the host filesystem */ }
+  const stat = fs.statSync(candidatePath);
+  if (!stat.isFile()) throw new Error('GitHub CLI candidate is not a file.');
+  if (stat.size > 64 * 1024) return false;
+  const text = fs.readFileSync(candidatePath, 'utf8').replaceAll('\\', '/').toLowerCase();
+  return text.includes(ROUTER_MARKER) || (text.includes('forge-workflow') && text.includes('/bin/gh.js'));
+}
+
+function resolveRealGh(options = {}) {
+  const platform = options.platform || process.platform;
+  const environment = options.env || process.env;
+  const pathValue = options.pathEnv ?? environmentValue(environment, 'PATH') ?? '';
+  const ownPath = options.ownPath ?? (isCompiledBinary() ? process.execPath : process.argv[1]);
+  const extensions = platform === 'win32'
+    ? (options.pathExt || environmentValue(environment, 'PATHEXT') || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean)
+    : [''];
+  for (const directory of pathValue.split(path.delimiter).filter(Boolean)) {
+    for (const extension of extensions) {
+      const candidate = path.join(directory, `gh${extension.toLowerCase()}`);
+      try {
+        fs.accessSync(candidate, platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK);
+        if (!isForgeProxy(candidate, ownPath)) return candidate;
+      } catch { /* keep searching */ }
+    }
+  }
+  return null;
+}
+
+function runNativeGh(args, projectRoot = process.cwd(), options = {}) {
+  const writeError = options.writeError || (value => process.stderr.write(value));
+  const executable = (options.resolveExecutable || resolveRealGh)(options);
+  if (!executable) {
+    writeError('GitHub CLI executable not found outside the Forge proxy.\n');
+    return 127;
+  }
+  return exitCode((options.spawnSync || spawnSync)(executable, args, {
+    cwd: projectRoot,
+    env: withoutProxyMarker(options.baseEnv || process.env),
+    stdio: 'inherit',
+    shell: false,
+  }));
+}
+
+module.exports = {
+  commandName, exitCode, isForgeProxy, isLocalGhInvocation, resolveRealGh, runNativeGh, shortOptionValue, withoutProxyMarker,
+};

package/lib/npm-publish-workflow.js

@@ -12,11 +12,11 @@ const {
 } = require('./protected-state-surfaces');
 const {
 	completeNpmPublishWorkflowAuthorization,
+	isValidGitObjectId,
 	issueNpmPublishWorkflowAuthorization,
 } = require('./protected-state-authority');
 
 const NPM_PUBLISH_WORKFLOW_PATH = '.github/workflows/npm-publish.yml';
-const FULL_COMMIT_SHA = /^[0-9a-f]{40}$/;
 const BUN_VERSION = /^bun@(\d+\.\d+\.\d+)$/.exec(require('../package.json').packageManager)?.[1];
 if (!BUN_VERSION) throw new Error('package.json must pin an exact stable Bun version.');
 
@@ -64,8 +64,8 @@ function verifyExpectedHead(projectRoot, expectedHead, resolveHead = resolveCurr
 	if (!expectedHead) {
 		return { success: false, error: '--expect-head is required for protected workflow generation.' };
 	}
-	if (!FULL_COMMIT_SHA.test(expectedHead)) {
-		return { success: false, error: '--expect-head must be a full 40-character lowercase commit SHA.' };
+	if (!isValidGitObjectId(expectedHead)) {
+		return { success: false, error: '--expect-head must be a full 40- or 64-character lowercase commit SHA.' };
 	}
 
 	let currentHead;
@@ -74,8 +74,8 @@ function verifyExpectedHead(projectRoot, expectedHead, resolveHead = resolveCurr
 	} catch (error) {
 		return { success: false, error: `Could not resolve current HEAD: ${error.message}` };
 	}
-	if (!FULL_COMMIT_SHA.test(currentHead)) {
-		return { success: false, error: 'Current HEAD did not resolve to a full 40-character lowercase commit SHA.' };
+	if (!isValidGitObjectId(currentHead)) {
+		return { success: false, error: 'Current HEAD did not resolve to a full 40- or 64-character lowercase commit SHA.' };
 	}
 	if (currentHead !== expectedHead) {
 		return {

package/lib/pr-monitor/flow-monitor.js

@@ -3,7 +3,7 @@
 const crypto = require('node:crypto');
 const zlib = require('node:zlib');
 
-const { computeContentHash, validateContractStructure } = require('../../packages/memory-contracts');
+const { computeContentHash, validateContractStructure } = require('@forge/contracts');
 const {
   MonitorRuntimeError,
   createMonitorDurabilityBridge,
@@ -11,7 +11,7 @@ const {
   createMonitorState,
   reduceMonitor,
   reduceMonitorBatch,
-} = require('../../packages/flow');
+} = require('@forge/flow');
 const { diffSnapshots } = require('./differ');
 const { EVENT_TYPES: T, makeEvent } = require('./events');
 const { finalizeRecords, MAX_EVENT_DELTAS } = require('./monitor');
@@ -139,7 +139,7 @@ function durableMonitorRecord(record) {
   };
 }
 
-function encodePendingBatch(ctx, subjectRevision, records, snapshot) {
+function encodeBoundedPendingBatch(ctx, subjectRevision, records, snapshot) {
   if (records.length < 1 || records.length > PENDING_BATCH_RECORD_LIMIT) {
     throw new FlowMonitorError('INVALID_OBSERVATION', 'Pending monitor transition batch exceeds its record bound');
   }
@@ -147,7 +147,7 @@ function encodePendingBatch(ctx, subjectRevision, records, snapshot) {
     monitor_id: ctx.monitorId,
     subject_revision: subjectRevision,
     snapshot_identity: snapshot === null ? null : snapshotIdentity(snapshot),
-    records: records.map(durableMonitorRecord),
+    records,
     snapshot,
   };
   const serialized = JSON.stringify({
@@ -164,6 +164,18 @@ function encodePendingBatch(ctx, subjectRevision, records, snapshot) {
   return encoded;
 }
 
+function encodePendingBatch(ctx, subjectRevision, records, snapshot) {
+  if (records.length < 1 || records.length > PENDING_BATCH_RECORD_LIMIT) {
+    throw new FlowMonitorError('INVALID_OBSERVATION', 'Pending monitor transition batch exceeds its record bound');
+  }
+  return encodeBoundedPendingBatch(
+    ctx,
+    subjectRevision,
+    records.map(durableMonitorRecord),
+    snapshot,
+  );
+}
+
 function decodePendingBatch(value, ctx, subjectRevision) {
   if (typeof value !== 'string' || value.length > PENDING_BATCH_LIMIT) {
     throw new FlowMonitorError('MONITOR_HISTORY_INCOMPLETE', 'Pending monitor transition batch is missing');
@@ -196,41 +208,126 @@ function segmentablePendingBatchError(error) {
     ].includes(error.message);
 }
 
-function splitPendingBatches(ctx, subjectRevision, records, snapshot) {
-  const batches = [];
-  let offset = 0;
-  while (offset < records.length) {
+function findAdaptiveBatchBoundary(maxCount, preferredCount, encode) {
+  if (!Number.isSafeInteger(maxCount) || maxCount < 1) return null;
+  let accepted = null;
+  const attempt = (count) => {
     try {
-      const encoded = encodePendingBatch(ctx, subjectRevision, records.slice(offset), snapshot);
-      appendPendingBatch(batches, { encoded, records: records.slice(offset), snapshot });
-      break;
+      accepted = { count, encoded: encode(count) };
+      return true;
     } catch (error) {
       if (!segmentablePendingBatchError(error)) throw error;
+      return false;
     }
-
+  };
+  const initialCount = Math.min(maxCount, Math.max(1, preferredCount || 1));
+  if (!attempt(initialCount)) {
     let low = 1;
-    let high = records.length - offset - 1;
-    let accepted = null;
+    let high = initialCount - 1;
     while (low <= high) {
       const count = Math.floor((low + high) / 2);
-      const candidate = records.slice(offset, offset + count);
-      try {
-        accepted = {
-          count,
-          encoded: encodePendingBatch(ctx, subjectRevision, candidate, null),
-          records: candidate,
-          snapshot: null,
-        };
-        low = count + 1;
-      } catch (error) {
-        if (!segmentablePendingBatchError(error)) throw error;
-        high = count - 1;
-      }
+      if (attempt(count)) low = count + 1;
+      else high = count - 1;
+    }
+    return accepted;
+  }
+
+  let low = initialCount + 1;
+  let probe = Math.min(maxCount, Math.max(low, initialCount * 2));
+  while (low <= maxCount) {
+    if (attempt(probe)) {
+      low = probe + 1;
+      if (probe === maxCount) break;
+      probe = Math.min(maxCount, Math.max(low, probe * 2));
+      continue;
+    }
+    let high = probe - 1;
+    while (low <= high) {
+      const count = Math.floor((low + high) / 2);
+      if (attempt(count)) low = count + 1;
+      else high = count - 1;
+    }
+    break;
+  }
+  return accepted;
+}
+
+function splitPendingBatches(
+  ctx,
+  subjectRevision,
+  records,
+  snapshot,
+  encodeBatch = encodeBoundedPendingBatch,
+) {
+  const batches = [];
+  if (records.length === 0) return batches;
+  if (records.length > PENDING_BATCH_RECORD_LIMIT) {
+    throw new FlowMonitorError('INVALID_OBSERVATION', 'Pending monitor transition batch exceeds its record bound');
+  }
+  const boundedRecords = records.map(durableMonitorRecord);
+  let offset = 0;
+  let preferredCount = 1;
+  let failedTerminalCount = null;
+  const appendTerminalBatch = (start) => {
+    const remainingCount = records.length - start;
+    try {
+      const encoded = encodeBatch(ctx, subjectRevision, boundedRecords.slice(start), snapshot);
+      appendPendingBatch(batches, { encoded, records: records.slice(start), snapshot });
+      return true;
+    } catch (error) {
+      if (!segmentablePendingBatchError(error)) throw error;
+      failedTerminalCount = remainingCount;
+      return false;
+    }
+  };
+
+  if (appendTerminalBatch(0)) return batches;
+
+  while (offset < records.length) {
+    const remainingCount = records.length - offset;
+    let accepted = findAdaptiveBatchBoundary(
+      remainingCount,
+      preferredCount,
+      count => encodeBatch(
+        ctx,
+        subjectRevision,
+        boundedRecords.slice(offset, offset + count),
+        null,
+      ),
+    );
+    if (!accepted && failedTerminalCount !== remainingCount && appendTerminalBatch(offset)) break;
+    if (accepted?.count === remainingCount && failedTerminalCount !== remainingCount) {
+      if (appendTerminalBatch(offset)) break;
+    }
+    if (accepted?.count === remainingCount) {
+      accepted = findAdaptiveBatchBoundary(
+        remainingCount - 1,
+        Math.min(preferredCount, remainingCount - 1),
+        count => encodeBatch(
+          ctx,
+          subjectRevision,
+          boundedRecords.slice(offset, offset + count),
+          null,
+        ),
+      );
+    }
+    if (accepted?.count < remainingCount
+      && batches.length === BATCH_PLAN_SEGMENT_LIMIT - 1) {
+      if (failedTerminalCount !== remainingCount && appendTerminalBatch(offset)) break;
+      throw new FlowMonitorError(
+        'INVALID_OBSERVATION',
+        'Pending monitor transition plan exceeds its segment bound',
+      );
     }
     if (!accepted) {
       throw new FlowMonitorError('INVALID_OBSERVATION', 'Pending monitor transition record exceeds its durable bound');
     }
-    appendPendingBatch(batches, accepted);
+    appendPendingBatch(batches, {
+      encoded: accepted.encoded,
+      records: records.slice(offset, offset + accepted.count),
+      snapshot: null,
+    });
+    preferredCount = accepted.count;
     offset += accepted.count;
   }
   return batches;
@@ -1418,7 +1515,9 @@ module.exports = {
     appendPendingBatch,
     decodePrivateSafeBase64,
     encodePrivateSafeBase64,
+    findAdaptiveBatchBoundary,
     remainingSegmentedRecords,
+    splitPendingBatches,
     validOrphanedPrecommitPlan,
   },
 };

package/lib/pr-monitor/reconcile-executor.js

@@ -1081,7 +1081,7 @@ async function migrateLegacyAuthority(projectRoot, opts = {}) {
 
 async function defaultBuildBroker({ projectRoot, gitCommonDir }) {
 	const { buildMigratedKernelIssueDeps } = require('../kernel/cli-broker-factory');
-	const { createMonitorStore } = require('../../packages/memory');
+	const { createMonitorStore } = require('@forge/memory');
 	const deps = await buildMigratedKernelIssueDeps({ projectRoot, gitCommonDir });
 	const store = createMonitorStore(deps.kernelDriver);
 	return {

package/lib/project-memory.js

@@ -8,7 +8,7 @@ const { resolveKernelDatabasePath } = require('./kernel/cli-broker-factory');
 const { resolveGitCommonDir } = require('./kernel/broker');
 const { createBuiltinSQLiteDriver } = require('./kernel/sqlite-driver');
 const { normalizeRecallHit } = require('./memory-recall');
-const { createUsageEvidenceStore } = require('../packages/memory');
+const { createUsageEvidenceStore } = require('@forge/memory');
 
 // Project memory is a Forge read model persisted in the kernel store (kernel_memories),
 // written DIRECTLY rather than through the issue CAS/guarded-event path. The store seam