cogmem 3.6.2

package/dist/retrieval/NativeQueryParser.js

@@ -0,0 +1,135 @@
+const DIRECTIVE_KEYS = new Set([
+    'entity',
+    'entityType',
+    'project',
+    'branch',
+    'task',
+    'cluster',
+    'time',
+    'from',
+    'to',
+    'around',
+    'mode'
+]);
+export class NativeQueryParser {
+    static KEY_ALIASES = {
+        entity: 'entity',
+        entitytype: 'entityType',
+        project: 'project',
+        branch: 'branch',
+        task: 'task',
+        cluster: 'cluster',
+        time: 'time',
+        from: 'from',
+        to: 'to',
+        around: 'around',
+        mode: 'mode'
+    };
+    parse(query) {
+        const clauses = [];
+        const consumed = [];
+        let index = 0;
+        while (index < query.length) {
+            index = this.skipWhitespace(query, index);
+            const keyMatch = this.readIdentifier(query, index);
+            if (!keyMatch) {
+                index += 1;
+                continue;
+            }
+            const key = NativeQueryParser.KEY_ALIASES[keyMatch.value.toLowerCase()];
+            const colonIndex = this.skipWhitespace(query, keyMatch.end);
+            if (!key || !DIRECTIVE_KEYS.has(key) || query[colonIndex] !== ':') {
+                index = keyMatch.end;
+                continue;
+            }
+            const valueStart = this.skipWhitespace(query, colonIndex + 1);
+            const valueMatch = this.readValue(query, valueStart);
+            if (!valueMatch) {
+                index = colonIndex + 1;
+                continue;
+            }
+            clauses.push({
+                key,
+                value: valueMatch.value,
+                raw: query.slice(index, valueMatch.end),
+                start: index,
+                end: valueMatch.end
+            });
+            consumed.push({ start: index, end: valueMatch.end });
+            index = valueMatch.end;
+        }
+        const directives = clauses.reduce((acc, clause) => {
+            if (clause.key === 'mode') {
+                if (clause.value === 'continuous' || clause.value === 'focused')
+                    acc.mode = clause.value;
+                return acc;
+            }
+            acc[clause.key] = clause.value;
+            return acc;
+        }, {});
+        return {
+            directives: Object.keys(directives).length > 0 ? directives : undefined,
+            clauses,
+            residualQuery: this.buildResidualQuery(query, consumed),
+            parseMode: 'grammar'
+        };
+    }
+    buildResidualQuery(query, consumed) {
+        if (consumed.length === 0)
+            return query.trim();
+        const sorted = consumed.slice().sort((a, b) => a.start - b.start);
+        let cursor = 0;
+        const parts = [];
+        for (const range of sorted) {
+            if (cursor < range.start)
+                parts.push(query.slice(cursor, range.start));
+            cursor = range.end;
+        }
+        if (cursor < query.length)
+            parts.push(query.slice(cursor));
+        return parts.join(' ').replace(/\s+/g, ' ').trim();
+    }
+    readIdentifier(query, index) {
+        const match = query.slice(index).match(/^([A-Za-z_][A-Za-z0-9_]*)/);
+        if (!match)
+            return null;
+        return {
+            value: match[1],
+            end: index + match[1].length
+        };
+    }
+    readValue(query, index) {
+        const quote = query[index];
+        if (quote === '"' || quote === '\'') {
+            let cursor = index + 1;
+            while (cursor < query.length) {
+                if (query[cursor] === quote && query[cursor - 1] !== '\\') {
+                    return {
+                        value: query.slice(index + 1, cursor).trim(),
+                        end: cursor + 1
+                    };
+                }
+                cursor += 1;
+            }
+            return {
+                value: query.slice(index + 1).trim(),
+                end: query.length
+            };
+        }
+        let cursor = index;
+        while (cursor < query.length) {
+            const char = query[cursor];
+            if (/\s/.test(char))
+                break;
+            cursor += 1;
+        }
+        const value = query.slice(index, cursor).trim();
+        return value.length > 0 ? { value, end: cursor } : null;
+    }
+    skipWhitespace(query, index) {
+        let cursor = index;
+        while (cursor < query.length && /\s/.test(query[cursor] || ''))
+            cursor += 1;
+        return cursor;
+    }
+}

package/dist/retrieval/PlanDslExecutor.d.ts

@@ -0,0 +1,67 @@
+import type { PlanRuntimeStore } from '../store/PlanRuntimeStore.js';
+export interface PlanExecutionContext {
+    completedSteps?: string[];
+    availableChecks?: string[];
+    approvals?: string[];
+    availableExecutors?: string[];
+    activePolicies?: string[];
+    entityStates?: Record<string, string>;
+    mergeArtifacts?: string[];
+}
+export interface PlanExecutionAnalysis {
+    executableSteps: string[];
+    blockedSteps: Array<{
+        step: string;
+        reasons: string[];
+    }>;
+    retryableTargets: Array<{
+        target: string;
+        maxAttempts: number;
+        backoff?: string;
+    }>;
+    mergeReadiness: Array<{
+        into: string;
+        ready: boolean;
+        missing: string[];
+    }>;
+    propagationTargets: Array<{
+        into: string;
+        propagates: string[];
+    }>;
+    executorMatches: Array<{
+        target: string;
+        executor: string;
+        mode?: string;
+        matched: boolean;
+    }>;
+    validationReadiness: Array<{
+        target: string;
+        ready: boolean;
+        missingChecks: string[];
+    }>;
+    policyCoverage: Array<{
+        target: string;
+        policy: string;
+        matched: boolean;
+        mode?: string;
+    }>;
+    stateProgress: Array<{
+        entity: string;
+        current?: string;
+        matched: boolean;
+        states: string[];
+    }>;
+}
+export interface PersistedPlanExecution extends PlanExecutionAnalysis {
+    runtimeId: string;
+}
+export declare class PlanDslExecutor {
+    static analyze(planDsl: unknown, context: PlanExecutionContext): PlanExecutionAnalysis;
+    static persistAnalysis(runtimeId: string, analysis: PlanExecutionAnalysis, store: PlanRuntimeStore): PersistedPlanExecution;
+    private static writeState;
+    private static normalizeContext;
+    private static hasArtifact;
+    private static asArray;
+    private static asStringArray;
+}
+//# sourceMappingURL=PlanDslExecutor.d.ts.map

package/dist/retrieval/PlanDslExecutor.js

@@ -0,0 +1,194 @@
+export class PlanDslExecutor {
+    static analyze(planDsl, context) {
+        const normalized = this.normalizeContext(context);
+        const dsl = (planDsl && typeof planDsl === 'object') ? planDsl : {};
+        const entrySteps = this.asStringArray(dsl.entrySteps);
+        const executionGuards = this.asArray(dsl.executionGuards);
+        const retryPolicies = this.asArray(dsl.retryPolicies);
+        const mergeConstraints = this.asArray(dsl.mergeConstraints);
+        const mergePropagation = this.asArray(dsl.mergePropagation);
+        const runtimeValidation = this.asArray(dsl.runtimeValidation);
+        const executorBindings = this.asArray(dsl.executorBindings);
+        const policyRuntime = this.asArray(dsl.policyRuntime);
+        const stateMachines = this.asArray(dsl.stateMachines);
+        const blockedSteps = [];
+        const executableSteps = [];
+        for (const step of entrySteps) {
+            const reasons = [];
+            const guard = executionGuards.find((item) => item.target === step);
+            if (guard) {
+                const missing = (guard.requires || []).filter((requirement) => !this.hasArtifact(normalized, requirement));
+                if (missing.length > 0)
+                    reasons.push(`guard_missing:${missing.join(',')}`);
+            }
+            const validation = runtimeValidation.find((item) => item.target === step);
+            if (validation) {
+                const missingChecks = (validation.checks || []).filter((check) => !this.hasArtifact(normalized, check));
+                if (missingChecks.length > 0)
+                    reasons.push(`validation_missing:${missingChecks.join(',')}`);
+            }
+            const binding = executorBindings.find((item) => item.target === step);
+            if (binding?.executor && !normalized.executors.has(binding.executor)) {
+                reasons.push(`executor_missing:${binding.executor}`);
+            }
+            if (reasons.length > 0)
+                blockedSteps.push({ step, reasons });
+            else
+                executableSteps.push(step);
+        }
+        const mergeReadiness = mergeConstraints.map((constraint) => {
+            const requires = (constraint.requires || []).filter(Boolean);
+            const missing = requires.filter((requirement) => !this.hasArtifact(normalized, requirement));
+            return {
+                into: String(constraint.into || ''),
+                ready: missing.length === 0,
+                missing
+            };
+        }).filter((item) => item.into);
+        const propagationTargets = mergePropagation.map((propagation) => ({
+            into: String(propagation.into || ''),
+            propagates: (propagation.propagates || []).filter(Boolean)
+        })).filter((item) => item.into && item.propagates.length > 0);
+        const validationReadiness = runtimeValidation.map((validation) => {
+            const checks = (validation.checks || []).filter(Boolean);
+            const missingChecks = checks.filter((check) => !this.hasArtifact(normalized, check));
+            return {
+                target: String(validation.target || ''),
+                ready: missingChecks.length === 0,
+                missingChecks
+            };
+        }).filter((item) => item.target);
+        const executorMatches = executorBindings.map((binding) => ({
+            target: String(binding.target || ''),
+            executor: String(binding.executor || ''),
+            mode: binding.mode,
+            matched: Boolean(binding.executor && normalized.executors.has(binding.executor))
+        })).filter((item) => item.target && item.executor);
+        const policyCoverage = policyRuntime.map((runtime) => ({
+            target: String(runtime.target || ''),
+            policy: String(runtime.policy || ''),
+            mode: runtime.mode,
+            matched: Boolean(runtime.policy && normalized.policies.has(runtime.policy))
+        })).filter((item) => item.target && item.policy);
+        const stateProgress = stateMachines.map((machine) => {
+            const entity = String(machine.entity || '');
+            const current = entity ? normalized.entityStates.get(entity) : undefined;
+            const states = (machine.states || []).filter(Boolean);
+            return {
+                entity,
+                current,
+                matched: Boolean(current && states.includes(current)),
+                states
+            };
+        }).filter((item) => item.entity);
+        const retryableTargets = retryPolicies
+            .filter((policy) => policy.target && typeof policy.maxAttempts === 'number')
+            .map((policy) => ({
+            target: String(policy.target),
+            maxAttempts: Number(policy.maxAttempts),
+            backoff: policy.backoff
+        }));
+        return {
+            executableSteps,
+            blockedSteps,
+            retryableTargets,
+            mergeReadiness,
+            propagationTargets,
+            executorMatches,
+            validationReadiness,
+            policyCoverage,
+            stateProgress
+        };
+    }
+    static persistAnalysis(runtimeId, analysis, store) {
+        for (const step of analysis.executableSteps) {
+            this.writeState(store, runtimeId, 'step', step, 'ready', { executable: true });
+        }
+        for (const blocked of analysis.blockedSteps) {
+            this.writeState(store, runtimeId, 'step', blocked.step, 'blocked', { reasons: blocked.reasons });
+        }
+        for (const merge of analysis.mergeReadiness) {
+            this.writeState(store, runtimeId, 'merge', merge.into, merge.ready ? 'ready' : 'blocked', { missing: merge.missing });
+        }
+        for (const validation of analysis.validationReadiness) {
+            this.writeState(store, runtimeId, 'validation', validation.target, validation.ready ? 'ready' : 'blocked', {
+                missingChecks: validation.missingChecks
+            });
+        }
+        for (const executor of analysis.executorMatches) {
+            this.writeState(store, runtimeId, 'executor', executor.target, executor.matched ? 'matched' : 'missing', {
+                executor: executor.executor,
+                mode: executor.mode
+            });
+        }
+        for (const policy of analysis.policyCoverage) {
+            this.writeState(store, runtimeId, 'policy', policy.target, policy.matched ? 'matched' : 'missing', {
+                policy: policy.policy,
+                mode: policy.mode
+            });
+        }
+        for (const state of analysis.stateProgress) {
+            this.writeState(store, runtimeId, 'state_machine', state.entity, state.matched ? 'matched' : 'pending', {
+                current: state.current,
+                states: state.states
+            });
+        }
+        for (const propagation of analysis.propagationTargets) {
+            store.recordTransition({
+                runtimeId,
+                entityType: 'merge',
+                entityKey: propagation.into,
+                transitionType: 'merge_propagation',
+                toStatus: 'ready',
+                payload: { propagates: propagation.propagates }
+            });
+        }
+        return {
+            runtimeId,
+            ...analysis
+        };
+    }
+    static writeState(store, runtimeId, entityType, entityKey, status, metadata) {
+        store.upsertState({
+            runtimeId,
+            entityType,
+            entityKey,
+            status,
+            metadata
+        });
+    }
+    static normalizeContext(context) {
+        const normalizeSet = (items) => new Set((items || []).map((item) => item.trim().toLowerCase()).filter(Boolean));
+        const entityStates = new Map();
+        for (const [entity, state] of Object.entries(context.entityStates || {})) {
+            if (!entity || !state)
+                continue;
+            entityStates.set(entity.trim().toLowerCase(), state.trim().toLowerCase());
+        }
+        return {
+            completed: normalizeSet(context.completedSteps),
+            checks: normalizeSet(context.availableChecks),
+            approvals: normalizeSet(context.approvals),
+            executors: normalizeSet(context.availableExecutors),
+            policies: normalizeSet(context.activePolicies),
+            mergeArtifacts: normalizeSet(context.mergeArtifacts),
+            entityStates
+        };
+    }
+    static hasArtifact(normalized, value) {
+        const item = value.trim().toLowerCase();
+        return normalized.completed.has(item)
+            || normalized.checks.has(item)
+            || normalized.approvals.has(item)
+            || normalized.mergeArtifacts.has(item)
+            || normalized.policies.has(item);
+    }
+    static asArray(value) {
+        return Array.isArray(value) ? value : [];
+    }
+    static asStringArray(value) {
+        return Array.isArray(value)
+            ? value.map((item) => String(item || '').trim().toLowerCase()).filter(Boolean)
+            : [];
+    }
+}

package/dist/retrieval/PolicyRuntimeEvaluator.d.ts

@@ -0,0 +1,48 @@
+import { type ConditionEvaluationContext } from './ConditionDslEvaluator.js';
+import { type PlanExecutionContext } from './PlanDslExecutor.js';
+import type { PlanRuntimeStore } from '../store/PlanRuntimeStore.js';
+import { type PolicySideEffectExecutor, type PolicySideEffectResult } from './PolicySideEffectExecutor.js';
+export interface PolicyRuntimeContext extends ConditionEvaluationContext, PlanExecutionContext {
+}
+export interface PolicyRuntimeDecision {
+    runtimeId?: string;
+    allowed: boolean;
+    executionReady: boolean;
+    reasons: string[];
+    policyActions: Array<{
+        policy: string;
+        action: 'allow' | 'deny' | 'prefer';
+    }>;
+    blockedSteps: Array<{
+        step: string;
+        reasons: string[];
+    }>;
+    executableSteps: string[];
+    mergeReadiness: Array<{
+        into: string;
+        ready: boolean;
+        missing: string[];
+    }>;
+    validationReadiness: Array<{
+        target: string;
+        ready: boolean;
+        missingChecks: string[];
+    }>;
+    executedEffects: PolicySideEffectResult[];
+}
+export declare class PolicyRuntimeEvaluator {
+    static evaluate(input: {
+        conditionDsl?: unknown;
+        planDsl?: unknown;
+        runtimeId?: string;
+        runtimeStore?: PlanRuntimeStore;
+    }, context: PolicyRuntimeContext): PolicyRuntimeDecision;
+    static evaluateAndExecute(input: {
+        conditionDsl?: unknown;
+        planDsl?: unknown;
+        runtimeId?: string;
+        runtimeStore?: PlanRuntimeStore;
+        sideEffectExecutor?: PolicySideEffectExecutor;
+    }, context: PolicyRuntimeContext): Promise<PolicyRuntimeDecision>;
+}
+//# sourceMappingURL=PolicyRuntimeEvaluator.d.ts.map

package/dist/retrieval/PolicyRuntimeEvaluator.js

@@ -0,0 +1,96 @@
+import { ConditionDslEvaluator } from './ConditionDslEvaluator.js';
+import { PlanDslExecutor } from './PlanDslExecutor.js';
+import { NoopPolicySideEffectExecutor } from './PolicySideEffectExecutor.js';
+export class PolicyRuntimeEvaluator {
+    static evaluate(input, context) {
+        const condition = input.conditionDsl
+            ? ConditionDslEvaluator.evaluate(input.conditionDsl, context)
+            : {
+                matched: true,
+                score: 0,
+                reasons: [],
+                executionReady: true,
+                normalizedContext: {},
+                policyActions: []
+            };
+        const plan = input.planDsl
+            ? PlanDslExecutor.analyze(input.planDsl, context)
+            : {
+                executableSteps: [],
+                blockedSteps: [],
+                retryableTargets: [],
+                mergeReadiness: [],
+                propagationTargets: [],
+                executorMatches: [],
+                validationReadiness: [],
+                policyCoverage: [],
+                stateProgress: []
+            };
+        if (input.runtimeId && input.runtimeStore) {
+            PlanDslExecutor.persistAnalysis(input.runtimeId, plan, input.runtimeStore);
+        }
+        const failedPolicies = plan.policyCoverage.filter((item) => !item.matched).map((item) => `policy_missing:${item.policy}`);
+        const missingExecutors = plan.executorMatches.filter((item) => !item.matched).map((item) => `executor_missing:${item.executor}`);
+        const blockedMerges = plan.mergeReadiness.filter((item) => !item.ready).map((item) => `merge_blocked:${item.into}`);
+        const failedValidation = plan.validationReadiness.filter((item) => !item.ready).map((item) => `validation_blocked:${item.target}`);
+        const reasons = [
+            ...condition.reasons,
+            ...failedPolicies,
+            ...missingExecutors,
+            ...blockedMerges,
+            ...failedValidation,
+            ...plan.blockedSteps.flatMap((item) => item.reasons.map((reason) => `${item.step}:${reason}`))
+        ];
+        const allowed = condition.matched
+            && failedPolicies.length === 0
+            && missingExecutors.length === 0
+            && blockedMerges.length === 0
+            && failedValidation.length === 0
+            && plan.blockedSteps.length === 0;
+        return {
+            runtimeId: input.runtimeId,
+            allowed,
+            executionReady: allowed && condition.executionReady,
+            reasons,
+            policyActions: condition.policyActions,
+            blockedSteps: plan.blockedSteps,
+            executableSteps: plan.executableSteps,
+            mergeReadiness: plan.mergeReadiness,
+            validationReadiness: plan.validationReadiness,
+            executedEffects: []
+        };
+    }
+    static async evaluateAndExecute(input, context) {
+        const decision = this.evaluate(input, context);
+        const executor = input.sideEffectExecutor || new NoopPolicySideEffectExecutor();
+        if (!decision.allowed || !decision.executionReady) {
+            return decision;
+        }
+        const planDsl = (input.planDsl && typeof input.planDsl === 'object')
+            ? input.planDsl
+            : {};
+        const policyRuntime = Array.isArray(planDsl.policyRuntime)
+            ? planDsl.policyRuntime
+            : [];
+        const executedEffects = [];
+        for (const policyAction of decision.policyActions) {
+            const target = policyRuntime.find((item) => item.policy === policyAction.policy)?.target
+                || decision.executableSteps[0];
+            const result = await executor.execute({
+                runtimeId: decision.runtimeId,
+                policy: policyAction.policy,
+                action: policyAction.action,
+                target,
+                metadata: {
+                    executableSteps: decision.executableSteps,
+                    blockedSteps: decision.blockedSteps
+                }
+            });
+            executedEffects.push(result);
+        }
+        return {
+            ...decision,
+            executedEffects
+        };
+    }
+}

package/dist/retrieval/PolicySideEffectExecutor.d.ts

@@ -0,0 +1,50 @@
+import type { PolicyExecutionStore, PolicyReplayPolicy } from '../store/PolicyExecutionStore.js';
+export interface PolicySideEffect {
+    runtimeId?: string;
+    policy: string;
+    action: 'allow' | 'deny' | 'prefer';
+    target?: string;
+    metadata?: Record<string, unknown>;
+    idempotencyKey?: string;
+    replayPolicy?: PolicyReplayPolicy;
+    actorId?: string;
+    causationId?: string;
+    correlationId?: string;
+    policyGroup?: string;
+}
+export interface PolicySideEffectResult {
+    policy: string;
+    action: 'allow' | 'deny' | 'prefer';
+    target?: string;
+    status: 'executed' | 'skipped' | 'failed';
+    detail?: string;
+}
+export interface PolicySideEffectExecutor {
+    execute(effect: PolicySideEffect): Promise<PolicySideEffectResult> | PolicySideEffectResult;
+}
+export interface ReliablePolicyExecutorOptions {
+    strategy?: 'linear' | 'exponential';
+    jitterRatio?: number;
+    maxBackoffMs?: number;
+}
+export declare class NoopPolicySideEffectExecutor implements PolicySideEffectExecutor {
+    execute(effect: PolicySideEffect): PolicySideEffectResult;
+}
+export declare class ReliablePolicySideEffectExecutor implements PolicySideEffectExecutor {
+    private delegate;
+    private store;
+    private maxRetries;
+    private backoffMs;
+    private strategy;
+    private jitterRatio;
+    private maxBackoffMs;
+    constructor(delegate: PolicySideEffectExecutor, store: PolicyExecutionStore, maxRetries?: number, backoffMs?: number, options?: ReliablePolicyExecutorOptions);
+    execute(effect: PolicySideEffect): Promise<PolicySideEffectResult>;
+    replay(runtimeId: string): PolicySideEffectResult[];
+    replayPending(now?: number): Promise<PolicySideEffectResult[]>;
+    getDeadLetters(runtimeId?: string): PolicySideEffectResult[];
+    private buildRecord;
+    private computeIdempotencyKey;
+    private computeBackoff;
+}
+//# sourceMappingURL=PolicySideEffectExecutor.d.ts.map