@guilz-dev/belay 0.7.0 → 0.8.1

package/dist/core/effect-ir/policy.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { policyDecisionToLegacyReason } from '../capability/policy-bridge.js';
-import { evaluateCapabilityRequestsPolicy, policyDecisionRequiresAsk, } from '../capability/policy-engine.js';
+import { evaluateEffectRequirementPolicy, policyDecisionRequiresAsk, } from '../capability/policy-engine.js';
 import { collectRequirements, flattenRequirementsToCapabilityRequests } from './build.js';
 function shellPrincipal(repoRoot, cwd) {
     return {
@@ -61,13 +61,100 @@ export function capabilityRequestsFromEffectPlan(plan, context) {
     });
 }
 export function evaluateEffectPlanPolicy(plan, context) {
+    const requirements = collectRequirements(plan.root);
     const capabilityRequests = capabilityRequestsFromEffectPlan(plan, context);
-    const { decisions, decision } = evaluateCapabilityRequestsPolicy(capabilityRequests, context.config, {
+    const decisions = requirements.map((requirement, index) => evaluateEffectRequirementPolicy({
+        tag: requirement.tag,
+        action: requirement.action,
+        resource: requirement.resource,
+        evidence: requirement.evidence,
+        provenance: requirement.provenance,
+    }, {
+        cwd: context.cwd,
+        repoRoot: context.repoRoot,
+        trustedWorkspaceRoots: context.trustedWorkspaceRoots,
+        sensitivePaths: context.sensitivePaths,
+        protectedArtifactRoots: context.protectedArtifactRoots,
         grants: context.grants,
-        attestation: context.attestation,
-        egressProxyActive: context.egressProxyActive,
-    }, context.trustedWorkspaceRoots);
-    return { capabilityRequests, decisions, authorizationDecision: decision };
+        capabilityRequest: capabilityRequests[index],
+    }));
+    const indeterminateIndexes = requirements.flatMap((requirement, index) => requirement.action === 'indeterminate' ||
+        requirement.tag === 'indeterminate' ||
+        requirement.evidence.level === 'indeterminate'
+        ? [index]
+        : []);
+    const unresolvedPartial = indeterminateIndexes.length === 0 ||
+        indeterminateIndexes.some((index) => decisions[index]?.matchedRule !== 'grant.exact');
+    if (plan.completeness === 'partial' && unresolvedPartial) {
+        decisions.push({
+            effectDisposition: 'ask',
+            outcome: 'require_approval',
+            reason: 'indeterminate_effect',
+            signals: [...plan.signals, 'effect_plan_partial'],
+            matchedRule: 'effect.plan_partial',
+        });
+    }
+    const worstDecision = worstEffectDecision(decisions);
+    const authorizationDecision = (worstDecision?.effectDisposition === 'ask'
+        ? worstDecision
+        : (decisions.find((decision) => decision.matchedRule === 'grant.exact') ?? worstDecision)) ??
+        {
+            outcome: 'allow',
+            reason: 'read_only',
+            signals: [],
+            matchedRule: 'effect.effect_free',
+        };
+    const projection = projectEffectPlanPolicy(decisions, authorizationDecision);
+    return {
+        capabilityRequests,
+        decisions,
+        authorizationDecision,
+        projection,
+    };
+}
+function dispositionRank(disposition) {
+    switch (disposition) {
+        case 'ask':
+            return 2;
+        case 'allow_flagged':
+            return 1;
+        case 'allow':
+            return 0;
+        default:
+            return 2;
+    }
+}
+function projectEffectPlanPolicy(decisions, authorizationDecision) {
+    const worst = worstEffectDecision(decisions);
+    if (!worst) {
+        return {
+            permission: 'allow',
+            hookVerdict: 'allow',
+            reason: 'read_only',
+        };
+    }
+    if (worst.effectDisposition === 'ask') {
+        return {
+            permission: 'ask',
+            hookVerdict: 'deny_pending_approval',
+            reason: policyDecisionToLegacyReason(authorizationDecision),
+        };
+    }
+    return {
+        permission: 'allow',
+        hookVerdict: worst.effectDisposition === 'allow_flagged' ? 'allow_flagged' : 'allow',
+        reason: policyDecisionToLegacyReason(worst),
+    };
+}
+function worstEffectDecision(decisions) {
+    let worst;
+    for (const decision of decisions) {
+        if (!worst ||
+            dispositionRank(decision.effectDisposition) > dispositionRank(worst.effectDisposition)) {
+            worst = decision;
+        }
+    }
+    return worst;
 }
 export function effectPlanPolicyRequiresAsk(decision) {
     return policyDecisionRequiresAsk(decision);

package/dist/core/effect-ir/shell-build.d.ts

@@ -0,0 +1,43 @@
+import type { CapabilityResource } from '../capability/request.js';
+import type { AnalysisCompleteness, EffectPlan, EffectRequirement } from './types.js';
+type ShellNetworkResource = Extract<CapabilityResource, {
+    kind: 'network';
+}> & Required<Pick<Extract<CapabilityResource, {
+    kind: 'network';
+}>, 'mode' | 'payload'>>;
+type ShellExecutableResource = Extract<CapabilityResource, {
+    kind: 'executable';
+}> & Required<Pick<Extract<CapabilityResource, {
+    kind: 'executable';
+}>, 'operation'>>;
+type ShellGitRefResource = Extract<CapabilityResource, {
+    kind: 'git-ref';
+}> & Required<Pick<Extract<CapabilityResource, {
+    kind: 'git-ref';
+}>, 'scope'>>;
+export type ShellEffectResource = Exclude<CapabilityResource, {
+    kind: 'network' | 'executable' | 'git-ref';
+}> | ShellNetworkResource | ShellExecutableResource | ShellGitRefResource;
+export type ShellEffectRequirement = Omit<EffectRequirement, 'resource'> & {
+    resource: ShellEffectResource;
+};
+export interface ShellEffectSegment {
+    commandRedacted: string;
+    segmentHead: string;
+    requirements: readonly ShellEffectRequirement[];
+    completeness: AnalysisCompleteness;
+    opacity: EffectPlan['opacity'];
+    signals: readonly string[];
+}
+export interface BuildShellEffectPlanParams {
+    inputFingerprint: string;
+    segments: readonly ShellEffectSegment[];
+    signals?: readonly string[];
+}
+/**
+ * Build a canonical EffectPlan from shell segments that have already been
+ * semantically analyzed. This function only assembles and normalizes effects;
+ * command-specific lowering belongs to the segment producers.
+ */
+export declare function buildShellEffectPlan(params: BuildShellEffectPlanParams): EffectPlan;
+export {};

package/dist/core/effect-ir/shell-build.js

@@ -0,0 +1,77 @@
+import { collectRequirements } from './build.js';
+import { mergeRequirements } from './normalize.js';
+/**
+ * Build a canonical EffectPlan from shell segments that have already been
+ * semantically analyzed. This function only assembles and normalizes effects;
+ * command-specific lowering belongs to the segment producers.
+ */
+export function buildShellEffectPlan(params) {
+    const nodes = params.segments.map(buildSegmentNode);
+    const root = mergeNodes(nodes);
+    const requirements = collectRequirements(root);
+    const completeness = requirements.some(isIndeterminateRequirement)
+        ? 'partial'
+        : 'complete';
+    return {
+        version: 1,
+        root,
+        inputFingerprint: params.inputFingerprint,
+        opacity: mergeOpacity(params.segments.map((segment) => segment.opacity)),
+        disposition: requirements.length === 0 ? 'effect_free' : 'effects',
+        completeness,
+        signals: [
+            ...new Set([
+                ...(params.signals ?? []),
+                ...params.segments.flatMap((segment) => [...segment.signals]),
+                ...requirements.flatMap((requirement) => [...requirement.evidence.signals]),
+            ]),
+        ].sort(),
+    };
+}
+function buildSegmentNode(segment) {
+    const requirements = mergeRequirements(segment.requirements);
+    const partial = segment.completeness === 'partial' ||
+        requirements.some((requirement) => requirement.evidence.level === 'indeterminate');
+    if (partial && !requirements.some(isIndeterminateRequirement)) {
+        const provenance = { segment: segment.commandRedacted };
+        requirements.push({
+            tag: 'indeterminate',
+            action: 'indeterminate',
+            resource: { kind: 'unknown' },
+            evidence: {
+                level: 'indeterminate',
+                signals: [...new Set([...segment.signals, 'effect_plan.segment_partial'])],
+                basis: [`shell_segment:${segment.segmentHead}`],
+            },
+            provenance,
+            provenances: [provenance],
+        });
+    }
+    return {
+        kind: 'exec',
+        commandRedacted: segment.commandRedacted,
+        segmentHead: segment.segmentHead,
+        requirements,
+    };
+}
+function isIndeterminateRequirement(requirement) {
+    return requirement.tag === 'indeterminate' || requirement.action === 'indeterminate';
+}
+function mergeNodes(nodes) {
+    if (nodes.length === 1 && nodes[0]) {
+        return nodes[0];
+    }
+    return { kind: 'merge', children: nodes };
+}
+function mergeOpacity(opacities) {
+    if (opacities.includes('unparseable')) {
+        return 'unparseable';
+    }
+    if (opacities.includes('opaque')) {
+        return 'opaque';
+    }
+    if (opacities.includes('recursive')) {
+        return 'recursive';
+    }
+    return 'transparent';
+}

package/dist/core/effect-ir/shell-lower.d.ts

@@ -0,0 +1,14 @@
+import type { EffectPlan } from './types.js';
+export interface LowerShellEffectPlanParams {
+    command: string;
+    cwd: string;
+    repoRoot: string;
+    inputFingerprint: string;
+    env?: Readonly<Record<string, string | undefined>>;
+}
+/**
+ * Parse and lower a general shell command into the canonical Task 2 model.
+ * This function only produces effects; it does not evaluate policy or return a
+ * permission/verdict.
+ */
+export declare function lowerShellEffectPlan(params: LowerShellEffectPlanParams): EffectPlan;