@guilz-dev/belay 0.6.0 → 0.8.0

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;