agentic-orchestrator 0.1.0

package/apps/control-plane/src/application/services/merge-service.ts

@@ -0,0 +1,246 @@
+import fs from 'node:fs/promises';
+import { nowIso } from '../../core/fs.js';
+import { runGit } from '../../core/git.js';
+import { ERROR_CODES } from '../../core/error-codes.js';
+import { fail } from '../../core/response.js';
+import { GATE_RESULT, STATUS } from '../../core/constants.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyRecord = Record<string, any>;
+
+type StateUpdater = (
+  frontMatter: AnyRecord,
+  body: string
+) => Promise<{ frontMatter?: AnyRecord; body?: string }>;
+
+function normalizeSet(array: string[]): string[] {
+  return [...new Set(array)].sort((a, b) => a.localeCompare(b));
+}
+
+function readHeldLocks(frontMatter: AnyRecord): string[] {
+  const locks = frontMatter?.locks && typeof frontMatter.locks === 'object' ? frontMatter.locks : {};
+  const held = Array.isArray(locks.held) ? locks.held : [];
+  return held.filter((item: unknown): item is string => typeof item === 'string');
+}
+
+function asRecord(value: unknown): AnyRecord {
+  return value && typeof value === 'object' ? (value as AnyRecord) : {};
+}
+
+function asArray<T = unknown>(value: unknown): T[] {
+  return Array.isArray(value) ? (value as T[]) : [];
+}
+
+export interface MergeServicePort {
+  getRepoRoot(): string;
+  getPolicySnapshot(): AnyRecord;
+  featurePath(featureId: string): string;
+  readState(featureId: string): Promise<{ frontMatter: AnyRecord; body: string }>;
+  worktreePath(featureId: string): string;
+  updateState(featureId: string, expectedVersion: number | null, updater: StateUpdater): Promise<AnyRecord>;
+  locksRelease(resource: string, featureId: string): Promise<unknown>;
+  withIndexLock<T>(operation: () => Promise<T>): Promise<T>;
+  readIndex(): Promise<AnyRecord>;
+  writeIndex(index: AnyRecord): Promise<void>;
+}
+
+export class MergeService {
+  private readonly port: MergeServicePort;
+
+  constructor(port: MergeServicePort) {
+    this.port = port;
+  }
+
+  async featureReadyToMerge(
+    featureId: string,
+    commitMessage: string,
+    mergeStrategy: string,
+    userApprovalToken: string | null
+  ): Promise<{ data: { feature_id: string; merge_sha: string; merge_strategy: string; status: string } }> {
+    const policy = this.port.getPolicySnapshot();
+    const state = await this.port.readState(featureId);
+
+    if (!policy.merge_policy.allowed_strategies.includes(mergeStrategy)) {
+      throw {
+        normalizedResponse: fail(ERROR_CODES.MERGE_DISABLED, 'Merge strategy is not allowed by policy', {
+          merge_strategy: mergeStrategy,
+          retryable: false,
+          requires_human: true
+        })
+      };
+    }
+
+    if (policy.merge_policy.require_user_approval && !userApprovalToken) {
+      throw {
+        normalizedResponse: fail(ERROR_CODES.USER_APPROVAL_REQUIRED, 'User approval token is required', {
+          retryable: false,
+          requires_human: true
+        })
+      };
+    }
+
+    if (state.frontMatter.status !== STATUS.READY_TO_MERGE) {
+      throw {
+        normalizedResponse: fail(ERROR_CODES.INVALID_STATUS_TRANSITION, 'Feature must be ready_to_merge before merge', {
+          current_status: state.frontMatter.status,
+          retryable: false,
+          requires_human: true
+        })
+      };
+    }
+
+    const requiredModes = [...policy.required_modes, policy.required_merge_mode];
+    for (const mode of requiredModes) {
+      if (state.frontMatter.gates?.[mode] !== GATE_RESULT.PASS) {
+        throw {
+          normalizedResponse: fail(ERROR_CODES.MERGE_DISABLED, 'Required gate mode has not passed', {
+            mode,
+            retryable: true,
+            requires_human: false
+          })
+        };
+      }
+    }
+
+    const repoRoot = this.port.getRepoRoot();
+    const featureWorktree = this.port.worktreePath(featureId);
+    const commitResult = await runGit(repoRoot, ['add', '-A'], { cwd: featureWorktree });
+    if (commitResult.code !== 0) {
+      throw {
+        normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Failed to stage changes before merge', {
+          stderr: commitResult.stderr,
+          retryable: true,
+          requires_human: false
+        })
+      };
+    }
+
+    const commit = await runGit(repoRoot, ['commit', '-m', commitMessage], { cwd: featureWorktree });
+    if (commit.code !== 0 && !commit.stderr.includes('nothing to commit')) {
+      throw {
+        normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Failed to commit feature branch', {
+          stderr: commit.stderr,
+          retryable: true,
+          requires_human: false
+        })
+      };
+    }
+
+    const baseBranch = policy.worktree.base_branch;
+    const checkoutBase = await runGit(repoRoot, ['checkout', baseBranch]);
+    if (checkoutBase.code !== 0) {
+      throw {
+        normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Failed to checkout base branch for merge', {
+          stderr: checkoutBase.stderr,
+          retryable: true,
+          requires_human: true
+        })
+      };
+    }
+
+    let merge;
+    if (mergeStrategy === 'merge_commit') {
+      merge = await runGit(repoRoot, ['merge', '--no-ff', featureId, '-m', `Merge feature ${featureId}`]);
+    } else if (mergeStrategy === 'squash') {
+      merge = await runGit(repoRoot, ['merge', '--squash', featureId]);
+      if (merge.code === 0) {
+        merge = await runGit(repoRoot, ['commit', '-m', `Squash merge ${featureId}`]);
+      }
+    } else {
+      const rebase = await runGit(repoRoot, ['rebase', baseBranch], { cwd: featureWorktree });
+      if (rebase.code !== 0) {
+        throw {
+          normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Rebase failed before merge', {
+            stderr: rebase.stderr,
+            retryable: true,
+            requires_human: true
+          })
+        };
+      }
+      merge = await runGit(repoRoot, ['merge', '--ff-only', featureId]);
+    }
+
+    if (merge.code !== 0) {
+      throw {
+        normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Merge failed', {
+          stderr: merge.stderr,
+          retryable: true,
+          requires_human: true
+        })
+      };
+    }
+
+    const mergeShaResult = await runGit(repoRoot, ['rev-parse', 'HEAD']);
+    const mergeSha = mergeShaResult.stdout.trim();
+
+    await this.port.updateState(featureId, state.frontMatter.version, (frontMatter, body) =>
+      Promise.resolve({
+        frontMatter: {
+          status: STATUS.MERGED,
+          status_reason: `Merged by strategy ${mergeStrategy}`,
+          evidence: {
+            ...(frontMatter.evidence ?? {}),
+            merge_sha: mergeSha,
+            merge_strategy: mergeStrategy,
+            merge_at: nowIso()
+          }
+        },
+        body: `${body}\n\n## Merge\n\nMerged at ${nowIso()} as ${mergeSha}.\n`
+      })
+    );
+
+    const heldLocks = [...readHeldLocks(state.frontMatter)];
+    for (const resource of heldLocks) {
+      await this.port.locksRelease(resource, featureId);
+    }
+
+    await this.port.withIndexLock(async () => {
+      const index = await this.port.readIndex();
+      index.active = normalizeSet(asArray<string>(index.active).filter((id) => id !== featureId));
+      index.blocked = normalizeSet(asArray<string>(index.blocked).filter((id) => id !== featureId));
+      index.merged = normalizeSet([...asArray<string>(index.merged), featureId]);
+
+      const blockedQueue = asArray<AnyRecord>(index.blocked_queue);
+      index.blocked_queue = blockedQueue.filter((entry) => asRecord(entry).feature_id !== featureId);
+
+      const locks = asRecord(index.locks);
+      for (const [resource, holder] of Object.entries(locks)) {
+        if (holder === featureId) {
+          locks[resource] = null;
+        }
+      }
+      index.locks = locks;
+
+      const lockLeases = asRecord(index.lock_leases);
+      for (const [resource, lease] of Object.entries(lockLeases)) {
+        if (asRecord(lease).holder === featureId) {
+          lockLeases[resource] = null;
+        }
+      }
+      index.lock_leases = lockLeases;
+
+      const runtimeSessions = asRecord(index.runtime_sessions);
+      const featureSessions = asRecord(runtimeSessions.feature_sessions);
+      if (Object.prototype.hasOwnProperty.call(featureSessions, featureId)) {
+        delete featureSessions[featureId];
+      }
+      runtimeSessions.feature_sessions = featureSessions;
+      index.runtime_sessions = runtimeSessions;
+
+      index.version += 1;
+      index.updated_at = nowIso();
+      await this.port.writeIndex(index);
+    });
+
+    await fs.rm(this.port.featurePath(featureId), { recursive: true, force: true });
+
+    return {
+      data: {
+        feature_id: featureId,
+        merge_sha: mergeSha,
+        merge_strategy: mergeStrategy,
+        status: STATUS.MERGED
+      }
+    };
+  }
+}

package/apps/control-plane/src/application/services/patch-service.ts

@@ -0,0 +1,259 @@
+import path from 'node:path';
+import {atomicWriteJson, readJson} from '../../core/fs.js';
+import {parseUnifiedDiff, touchedPathsFromDiff} from '../../core/patch.js';
+import {anyAreaMatch, normalizeRepoPath, sortResourcesDeterministically} from '../../core/path-rules.js';
+import {runGit} from '../../core/git.js';
+import {buildQaIndex, makeRequiredTests} from '../../core/qa-index.js';
+import {ERROR_CODES} from '../../core/error-codes.js';
+import {fail} from '../../core/response.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyRecord = Record<string, any>;
+
+type StateUpdater = (
+  frontMatter: AnyRecord,
+  body: string
+) => Promise<{ frontMatter?: AnyRecord; body?: string }>;
+
+function asArray<T = unknown>(value: unknown): T[] {
+  return Array.isArray(value) ? (value as T[]) : [];
+}
+
+function readObjectField(record: AnyRecord, key: string): AnyRecord {
+  const value = record[key];
+  return value && typeof value === 'object' ? (value as AnyRecord) : {};
+}
+
+function readHeldLocks(frontMatter: AnyRecord): string[] {
+  const locks = readObjectField(frontMatter, 'locks');
+  return asArray<string>(locks.held).filter((item) => typeof item === 'string');
+}
+
+function normalizeFromWorktree(worktreePath: string, repoRoot: string, repoRelativeFromWorktree: string): string {
+  const absolute = path.resolve(repoRoot, repoRelativeFromWorktree);
+  const maybeRelativeToWorktree = path.relative(worktreePath, absolute).replaceAll('\\\\', '/');
+  if (!maybeRelativeToWorktree.startsWith('../')) {
+    return maybeRelativeToWorktree;
+  }
+  return path.relative(repoRoot, absolute).replaceAll('\\\\', '/');
+}
+
+export interface PatchServicePort {
+  getRepoRoot(): string;
+  getPolicySnapshot(): AnyRecord;
+  getGatesConfig(): AnyRecord;
+  planPath(featureId: string): string;
+  qaIndexPath(featureId: string): string;
+  worktreePath(featureId: string): string;
+  readState(featureId: string): Promise<{ frontMatter: AnyRecord }>;
+  validateSchema(schemaName: string, value: unknown): Promise<{ valid: boolean; errors?: unknown }>;
+  updateState(featureId: string, expectedVersion: number | null, updater: StateUpdater): Promise<AnyRecord>;
+}
+
+export class PatchService {
+  private readonly port: PatchServicePort;
+
+  constructor(port: PatchServicePort) {
+    this.port = port;
+  }
+
+  async loadAcceptedPlan(featureId: string): Promise<AnyRecord | null> {
+    const plan = await readJson(this.port.planPath(featureId), null);
+    if (!plan && this.port.getPolicySnapshot().patch_policy.enforce_plan) {
+      throw {
+        normalizedResponse: fail(ERROR_CODES.PLAN_REQUIRED, 'Patch requires accepted plan', {
+          feature_id: featureId,
+          retryable: false,
+          requires_human: true,
+          suggested_next_actions: ['Submit plan before applying patches']
+        })
+      };
+    }
+    return plan;
+  }
+
+  requiredResourcesForPlan(plan: AnyRecord): string[] {
+    const resources: string[] = [];
+    const policy = this.port.getPolicySnapshot();
+    if (plan.contracts?.openapi === 'modify') {
+      resources.push(policy.locks.contract_to_resource.openapi);
+    }
+    if (plan.contracts?.events === 'modify') {
+      resources.push(policy.locks.contract_to_resource.events);
+    }
+    if (plan.contracts?.db === 'migration') {
+      resources.push(policy.locks.contract_to_resource.db);
+    }
+    return sortResourcesDeterministically(resources);
+  }
+
+  async assertPlanLocksHeld(featureId: string, plan: AnyRecord): Promise<void> {
+    const state = await this.port.readState(featureId);
+    const held = new Set(readHeldLocks(state.frontMatter));
+    const required = await this.requiredResourcesForPlan(plan);
+    const missing = required.filter((resource) => !held.has(resource));
+    if (missing.length > 0) {
+      throw {
+        normalizedResponse: fail(ERROR_CODES.LOCK_NOT_HELD, 'Plan requires lock(s) that are not held', {
+          feature_id: featureId,
+          missing_resources: missing,
+          retryable: true,
+          requires_human: false,
+          suggested_next_actions: ['Acquire required locks before applying patch']
+        })
+      };
+    }
+  }
+
+  async validatePatchPaths(
+    featureId: string,
+    parsedDiff: ReturnType<typeof parseUnifiedDiff>,
+    plan: AnyRecord | null
+  ): Promise<string[]> {
+    const policy = this.port.getPolicySnapshot();
+    const repoRoot = this.port.getRepoRoot();
+    const matchingMode = policy.path_rules.matching;
+    const allowSymlinkTraversal = policy.path_rules.allow_symlink_traversal;
+    const touched = touchedPathsFromDiff(parsedDiff);
+
+    const normalizedTouched: string[] = [];
+    for (const touchedPath of touched) {
+      const normalized = await normalizeRepoPath(
+        repoRoot,
+        path.join(this.port.worktreePath(featureId), touchedPath),
+        allowSymlinkTraversal
+      )
+        .then((relativePath) => normalizeFromWorktree(this.port.worktreePath(featureId), repoRoot, relativePath))
+        .catch(async () => {
+          return await normalizeRepoPath(repoRoot, touchedPath, allowSymlinkTraversal);
+        });
+      normalizedTouched.push(normalized);
+    }
+
+    const allowed = asArray<string>(plan?.allowed_areas);
+    const forbidden = asArray<string>(plan?.forbidden_areas);
+    const protectedAreas = asArray<string>(policy.protected_areas);
+
+    const plannedFiles = new Set([
+      ...asArray<string>(plan?.files?.create),
+      ...asArray<string>(plan?.files?.modify),
+      ...asArray<string>(plan?.files?.delete)
+    ]);
+
+    const violations: Array<{ path: string; reason: string }> = [];
+    for (const filePath of normalizedTouched) {
+      if (policy.patch_policy.enforce_allowed_areas && allowed.length > 0 && !anyAreaMatch(filePath, allowed, matchingMode)) {
+        violations.push({ path: filePath, reason: 'outside_allowed_areas' });
+      }
+      if (forbidden.length > 0 && anyAreaMatch(filePath, forbidden, matchingMode)) {
+        violations.push({ path: filePath, reason: 'in_forbidden_areas' });
+      }
+      if (protectedAreas.length > 0 && anyAreaMatch(filePath, protectedAreas, matchingMode)) {
+        violations.push({ path: filePath, reason: 'in_protected_areas' });
+      }
+      if (plan && !plannedFiles.has(filePath)) {
+        violations.push({ path: filePath, reason: 'not_in_planned_file_set' });
+      }
+    }
+
+    if (violations.length > 0) {
+      throw {
+        normalizedResponse: fail(ERROR_CODES.PATCH_POLICY_VIOLATION, 'Patch violates plan/policy constraints', {
+          feature_id: featureId,
+          violations,
+          retryable: false,
+          requires_human: true
+        })
+      };
+    }
+
+    return normalizedTouched;
+  }
+
+  async repoApplyPatch(
+    featureId: string,
+    unifiedDiff: string
+  ): Promise<{
+    data: {
+      feature_id: string;
+      changed_files: string[];
+      status_porcelain: string[];
+      qa_index_version: number;
+    };
+  }> {
+    const plan = await this.loadAcceptedPlan(featureId);
+    const parsedDiff = parseUnifiedDiff(unifiedDiff);
+
+    await this.validatePatchPaths(featureId, parsedDiff, plan);
+    await this.assertPlanLocksHeld(featureId, plan ?? { contracts: { openapi: 'none', events: 'none', db: 'none' } });
+
+    const repoRoot = this.port.getRepoRoot();
+    const worktree = this.port.worktreePath(featureId);
+    const apply = await runGit(repoRoot, ['apply', '--whitespace=nowarn', '-'], {
+      cwd: worktree,
+      stdin: unifiedDiff
+    });
+
+    if (apply.code !== 0) {
+      throw {
+        normalizedResponse: fail(
+          ERROR_CODES.GIT_FAILURE,
+          'git apply failed',
+          {
+            stderr: apply.stderr,
+            retryable: true,
+            requires_human: false
+          },
+          {
+            command: ['git', 'apply', '--whitespace=nowarn', '-'],
+            exit_code: apply.code
+          }
+        )
+      };
+    }
+
+    const status = await runGit(repoRoot, ['status', '--porcelain'], { cwd: worktree });
+    const changedFiles = (await runGit(repoRoot, ['diff', '--name-only'], { cwd: worktree })).stdout
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean);
+
+    const previousQaIndex = await readJson(this.port.qaIndexPath(featureId), null);
+    const profileName = plan?.gate_profile ?? 'default';
+    const profile = this.port.getGatesConfig().profiles[profileName];
+    const requiredTests = makeRequiredTests(profileName, profile);
+    const qaIndex = buildQaIndex(featureId, parsedDiff, requiredTests, previousQaIndex);
+
+    const qaValidation = await this.port.validateSchema('qa_test_index.schema.json', qaIndex);
+    if (!qaValidation.valid) {
+      throw {
+        normalizedResponse: fail(ERROR_CODES.INTERNAL_ERROR, 'qa_test_index validation failed', {
+          errors: qaValidation.errors,
+          retryable: false,
+          requires_human: true
+        })
+      };
+    }
+
+    await atomicWriteJson(this.port.qaIndexPath(featureId), qaIndex);
+
+    await this.port.updateState(featureId, null, (frontMatter, body) =>
+      Promise.resolve({
+        frontMatter: {
+          status: frontMatter.status,
+          gates: frontMatter.gates
+        },
+        body
+      })
+    );
+
+    return {
+      data: {
+        feature_id: featureId,
+        changed_files: changedFiles,
+        status_porcelain: status.stdout.trim().split('\n').filter(Boolean),
+        qa_index_version: qaIndex.version
+      }
+    };
+  }
+}