@kbediako/codex-orchestrator 0.1.38 → 0.2.0

package/dist/orchestrator/src/cli/planCliShell.js

@@ -0,0 +1,19 @@
+import process from 'node:process';
+import { formatPlanPreview } from './utils/planFormatter.js';
+const DEFAULT_DEPENDENCIES = {
+    formatPlanPreview,
+    stdout: process.stdout
+};
+export async function runPlanCliShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const result = await params.orchestrator.plan({
+        pipelineId: params.pipelineId,
+        taskId: params.taskId,
+        targetStageId: params.targetStageId
+    });
+    if (params.format === 'json') {
+        dependencies.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    dependencies.stdout.write(`${dependencies.formatPlanPreview(result)}\n`);
+}

package/dist/orchestrator/src/cli/prCliShell.js

@@ -0,0 +1,41 @@
+/* eslint-disable patterns/prefer-logger-over-console */
+import process from 'node:process';
+import { runPrWatchMerge } from '../../../scripts/lib/pr-watch-merge.js';
+const DEFAULT_DEPENDENCIES = {
+    runPrWatchMerge,
+    setExitCode: (code) => {
+        process.exitCode = code;
+    }
+};
+const MODE_BY_SUBCOMMAND = {
+    'watch-merge': {
+        usage: 'codex-orchestrator pr watch-merge',
+        readinessMode: 'merge'
+    },
+    'resolve-merge': {
+        usage: 'codex-orchestrator pr resolve-merge',
+        defaultExitOnActionRequired: true,
+        enableAutomaticBranchRecovery: true,
+        readinessMode: 'merge'
+    },
+    'ready-review': {
+        usage: 'codex-orchestrator pr ready-review',
+        defaultExitOnActionRequired: true,
+        readinessMode: 'review'
+    }
+};
+export async function runPrCliShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const [subcommand, ...subcommandArgs] = params.rawArgs;
+    if (!subcommand) {
+        throw new Error('pr requires a subcommand (watch-merge|resolve-merge|ready-review).');
+    }
+    const mode = MODE_BY_SUBCOMMAND[subcommand];
+    if (!mode) {
+        throw new Error(`Unknown pr subcommand: ${subcommand}`);
+    }
+    const exitCode = await dependencies.runPrWatchMerge(subcommandArgs, mode);
+    if (exitCode !== 0) {
+        dependencies.setExitCode(exitCode);
+    }
+}

package/dist/orchestrator/src/cli/providerLinearChildLanePhaseContract.js

@@ -0,0 +1,204 @@
+import { posix } from 'node:path';
+export const PROVIDER_LINEAR_CHILD_LANE_PHASE_CONTRACT_VERSION = 'phase-path-selectors-v1';
+const PROVIDER_LINEAR_CHILD_LANE_PHASE_SELECTOR_DEFINITIONS = {
+    docs: [
+        { kind: 'exact', value: 'AGENTS.md' },
+        { kind: 'prefix', value: '.agent/task/' },
+        { kind: 'prefix', value: 'docs/' },
+        { kind: 'prefix', value: 'skills/' },
+        { kind: 'prefix', value: 'tasks/' }
+    ],
+    implementation: [
+        { kind: 'prefix', value: 'bin/' },
+        { kind: 'exact', value: 'codex.orchestrator.json' },
+        { kind: 'prefix', value: 'orchestrator/src/' },
+        { kind: 'exact', value: 'package-lock.json' },
+        { kind: 'exact', value: 'package.json' },
+        { kind: 'prefix', value: 'scripts/' }
+    ],
+    tests: [
+        { kind: 'prefix', value: 'orchestrator/tests/' },
+        { kind: 'prefix', value: 'tests/' }
+    ]
+};
+function normalizeOptionalString(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object';
+}
+function normalizeScopeContractPath(value, kind) {
+    const normalizedInput = normalizeOptionalString(value);
+    if (!normalizedInput) {
+        return null;
+    }
+    const normalized = posix.normalize(normalizedInput.replaceAll('\\', '/'));
+    const withoutCurrentDir = normalized.replace(/^(?:\.\/)+/u, '');
+    const trimmed = withoutCurrentDir.replace(/\/+/gu, '/').replace(/\/$/u, '');
+    if (trimmed === '' || trimmed === '.' || trimmed === '..' || trimmed.startsWith('../')) {
+        return null;
+    }
+    if (kind === 'prefix') {
+        return `${trimmed}/`;
+    }
+    return trimmed;
+}
+function normalizePhaseName(value) {
+    const normalizedInput = normalizeOptionalString(value);
+    if (!normalizedInput) {
+        return null;
+    }
+    const normalized = normalizedInput.toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+}
+function selectorPathSignature(selector) {
+    return `${selector.kind}:${selector.value}`;
+}
+function selectorIdentitySignature(selector) {
+    return `${selector.kind}:${selector.value}:${selector.source}:${selector.phase ?? ''}`;
+}
+function dedupeSelectors(selectors) {
+    const seen = new Set();
+    const deduped = [];
+    for (const selector of selectors) {
+        const signature = selectorPathSignature(selector);
+        if (seen.has(signature)) {
+            continue;
+        }
+        seen.add(signature);
+        deduped.push(selector);
+    }
+    return deduped;
+}
+export function normalizeProviderLinearChildLanePathSelectors(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    const normalized = [];
+    const seen = new Set();
+    for (const entry of value) {
+        if (!isRecord(entry)) {
+            return null;
+        }
+        const kind = entry.kind === 'exact' || entry.kind === 'prefix' ? entry.kind : null;
+        const source = entry.source === 'file' || entry.source === 'phase' ? entry.source : null;
+        const rawValue = typeof entry.value === 'string' ? entry.value : null;
+        const normalizedValue = kind && rawValue ? normalizeScopeContractPath(rawValue, kind) : null;
+        if (!kind || !source || !rawValue || !normalizedValue || rawValue !== normalizedValue) {
+            return null;
+        }
+        const signature = selectorPathSignature({ kind, value: normalizedValue });
+        if (seen.has(signature)) {
+            return null;
+        }
+        seen.add(signature);
+        if (source === 'file') {
+            if (entry.phase !== undefined && entry.phase !== null) {
+                return null;
+            }
+            normalized.push({
+                kind,
+                value: normalizedValue,
+                source,
+                phase: null
+            });
+            continue;
+        }
+        const rawPhase = typeof entry.phase === 'string' ? entry.phase : null;
+        const phase = rawPhase ? normalizePhaseName(rawPhase) : null;
+        if (!rawPhase || !phase || rawPhase !== phase) {
+            return null;
+        }
+        normalized.push({
+            kind,
+            value: normalizedValue,
+            source,
+            phase
+        });
+    }
+    return normalized;
+}
+export function resolveProviderLinearChildLaneSupportedPhases() {
+    return Object.keys(PROVIDER_LINEAR_CHILD_LANE_PHASE_SELECTOR_DEFINITIONS).sort();
+}
+export function resolveProviderLinearChildLaneScopeContract(scope) {
+    const normalizedFiles = [
+        ...new Set((scope.files ?? [])
+            .map((entry) => normalizeScopeContractPath(String(entry), 'exact'))
+            .filter((entry) => entry !== null))
+    ];
+    const normalizedPhases = [
+        ...new Set((scope.phases ?? [])
+            .map((entry) => normalizePhaseName(String(entry)))
+            .filter((entry) => entry !== null))
+    ];
+    if (normalizedFiles.length === 0 && normalizedPhases.length === 0) {
+        throw new Error('Provider worker child lanes require at least one declared file or supported phase scope.');
+    }
+    const unsupportedPhases = normalizedPhases.filter((phase) => !Object.prototype.hasOwnProperty.call(PROVIDER_LINEAR_CHILD_LANE_PHASE_SELECTOR_DEFINITIONS, phase));
+    if (unsupportedPhases.length > 0) {
+        throw new Error(`Unsupported child-lane phases: ${unsupportedPhases.join(', ')}. Supported phases: ${resolveProviderLinearChildLaneSupportedPhases().join(', ')}.`);
+    }
+    const selectors = dedupeSelectors([
+        ...normalizedFiles.map((file) => ({
+            kind: 'exact',
+            value: file,
+            source: 'file',
+            phase: null
+        })),
+        ...normalizedPhases.flatMap((phase) => PROVIDER_LINEAR_CHILD_LANE_PHASE_SELECTOR_DEFINITIONS[phase].map((selector) => ({
+            kind: selector.kind,
+            value: selector.value,
+            source: 'phase',
+            phase
+        })))
+    ]);
+    return {
+        ...scope,
+        files: normalizedFiles,
+        phases: normalizedPhases,
+        phase_contract_version: PROVIDER_LINEAR_CHILD_LANE_PHASE_CONTRACT_VERSION,
+        allowed_path_selectors: selectors
+    };
+}
+export function providerLinearChildLanePathSelectorsEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    const leftSignatures = left.map((selector) => selectorIdentitySignature(selector)).sort();
+    const rightSignatures = right.map((selector) => selectorIdentitySignature(selector)).sort();
+    return leftSignatures.every((signature, index) => signature === rightSignatures[index]);
+}
+export function providerLinearChildLanePathMatchesSelectors(candidatePath, selectors) {
+    const normalizedCandidate = normalizeScopeContractPath(candidatePath, 'exact');
+    if (!normalizedCandidate) {
+        return false;
+    }
+    return selectors.some((selector) => selector.kind === 'exact'
+        ? selector.value === normalizedCandidate
+        : normalizedCandidate.startsWith(selector.value));
+}
+function pathSelectorsOverlap(left, right) {
+    if (left.kind === 'exact' && right.kind === 'exact') {
+        return left.value === right.value;
+    }
+    if (left.kind === 'exact' && right.kind === 'prefix') {
+        return left.value.startsWith(right.value);
+    }
+    if (left.kind === 'prefix' && right.kind === 'exact') {
+        return right.value.startsWith(left.value);
+    }
+    return left.value.startsWith(right.value) || right.value.startsWith(left.value);
+}
+export function providerLinearChildLanePathSelectorsOverlap(left, right) {
+    return left.some((leftSelector) => right.some((rightSelector) => pathSelectorsOverlap(leftSelector, rightSelector)));
+}
+export function formatProviderLinearChildLanePathSelectors(selectors) {
+    return selectors
+        .map((selector) => (selector.kind === 'exact' ? selector.value : `${selector.value}*`))
+        .join(', ');
+}