intentdna 1.4.4 → 1.4.5

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "intentdna",
       "description": "DNA template compilation + runtime enforcement",
-      "version": "1.4.4",
+      "version": "1.4.5",
       "source": "./"
     }
   ]

package/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "intentdna",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "description": "Declarative policy layer for AI agent governance"
 }

package/dist/compiler/workflow.d.ts

@@ -5,7 +5,7 @@
  * Performs topological sort, parallel group detection, transition compilation,
  * retry config resolution, cycle detection, and optional Mermaid diagram generation.
  */
-import type { WorkflowDef, WorkflowPlan, RoleDef } from "../schema/types.js";
+import type { WorkflowDef, WorkflowStepDef, WorkflowPlan, RoleDef, RawWorkflowStepEntry } from "../schema/types.js";
 export interface CompileWorkflowOptions {
     /** Generate Mermaid diagram (default: false) */
     mermaid?: boolean;
@@ -21,6 +21,22 @@ export interface CompileWorkflowResult {
     plan?: WorkflowPlan;
     errors: CompileWorkflowError[];
 }
+/**
+ * Expand parallel blocks into regular steps with depends_on.
+ *
+ * A parallel block:
+ *   - parallel:
+ *       isolation: worktree
+ *       steps: [{id: "a", role: "x"}, {id: "b", role: "y"}]
+ *
+ * Becomes:
+ *   - {id: "a", role: "x", depends_on: [<prev_step>], isolation: worktree}
+ *   - {id: "b", role: "y", depends_on: [<prev_step>], isolation: worktree}
+ *
+ * The step immediately before the parallel block is the dependency.
+ * If no previous step, the parallel steps have no depends_on.
+ */
+export declare function expandParallelBlocks(steps: RawWorkflowStepEntry[]): WorkflowStepDef[];
 /**
  * Check if two sets of write glob patterns have overlapping scope.
  * Uses prefix-based matching: "src/xx" and "src/lib/xx" overlap.

package/dist/compiler/workflow.js

@@ -6,6 +6,66 @@
  * retry config resolution, cycle detection, and optional Mermaid diagram generation.
  */
 // ── Internal helpers ─────────────────────────────────────────
+/**
+ * Type guard: check if a step entry is a parallel block (syntax sugar).
+ */
+function isParallelBlock(entry) {
+    return "parallel" in entry && typeof entry.parallel === "object";
+}
+/**
+ * Expand parallel blocks into regular steps with depends_on.
+ *
+ * A parallel block:
+ *   - parallel:
+ *       isolation: worktree
+ *       steps: [{id: "a", role: "x"}, {id: "b", role: "y"}]
+ *
+ * Becomes:
+ *   - {id: "a", role: "x", depends_on: [<prev_step>], isolation: worktree}
+ *   - {id: "b", role: "y", depends_on: [<prev_step>], isolation: worktree}
+ *
+ * The step immediately before the parallel block is the dependency.
+ * If no previous step, the parallel steps have no depends_on.
+ */
+export function expandParallelBlocks(steps) {
+    const result = [];
+    let lastStepId = null;
+    for (const entry of steps) {
+        if (isParallelBlock(entry)) {
+            const block = entry.parallel;
+            const expandedIds = [];
+            for (const inner of block.steps) {
+                const expanded = {
+                    ...inner,
+                    // Add depends_on from last step before this block
+                    depends_on: lastStepId
+                        ? [...(inner.depends_on ?? []), lastStepId]
+                        : inner.depends_on,
+                    // Inherit isolation from parallel block if step doesn't override
+                    isolation: inner.isolation ?? block.isolation,
+                };
+                result.push(expanded);
+                expandedIds.push(inner.id);
+            }
+            // After expansion, "lastStepId" stays as the set of expanded IDs.
+            // The next step should depend on ALL parallel steps.
+            // We can't set a single lastStepId, so we track it differently:
+            // We set lastStepId to null and let the NEXT regular step
+            // depend on all expanded IDs via explicit depends_on in the input.
+            // Actually, the simplest approach: peek at the next step.
+            // If the next step already has depends_on referencing these IDs, good.
+            // Otherwise, we need a way to inject deps.
+            // Since this is sugar, we rely on the user specifying depends_on
+            // on the join step (like in the spec example).
+            lastStepId = null; // Reset — next step must use explicit depends_on
+        }
+        else {
+            result.push(entry);
+            lastStepId = entry.id;
+        }
+    }
+    return result;
+}
 /**
  * If no step in the workflow has depends_on, inject implicit sequential
  * dependencies based on array order (step[i] depends_on step[i-1]).
@@ -332,8 +392,10 @@ export function compileWorkflow(workflow, options) {
         });
         return { ok: false, errors };
     }
+    // 1.5. Expand parallel blocks (syntax sugar) into regular steps
+    const expandedSteps = expandParallelBlocks(workflow.steps);
     // 2. Infer implicit deps if no step has depends_on
-    const resolvedSteps = inferImplicitDeps(workflow.steps);
+    const resolvedSteps = inferImplicitDeps(expandedSteps);
     // 3. Build dependency graph
     const graph = buildDependencyGraph(resolvedSteps);
     // 4. Topological sort + cycle detection

package/dist/runtime/workflow-runner.js

@@ -22,6 +22,13 @@ const SENTINEL_COMMENT = "# intentdna:managed -- do not edit manually";
 function sanitizeForBash(id) {
     return id.replace(/[^a-zA-Z0-9_]/g, "_");
 }
+/**
+ * Sanitize a step ID for safe use in shell paths and git branch names.
+ * Allows alphanumeric, hyphen, underscore, and dot only.
+ */
+function sanitizeForShell(id) {
+    return id.replace(/[^a-zA-Z0-9_.-]/g, "_");
+}
 /**
  * Get the agent name for a role, using toKebabCase and the configured prefix.
  */
@@ -203,7 +210,8 @@ function generateGroupExecution(group, stepMap, options, plan) {
     const lines = [];
     const isParallel = group.step_ids.length > 1;
     if (isParallel) {
-        lines.push(`  # Group ${group.group_index}: ${group.step_ids.join(", ")} (parallel)`);
+        const isoLabel = group.isolation === "worktree" ? "parallel, worktree" : "parallel";
+        lines.push(`  # Group ${group.group_index}: ${group.step_ids.join(", ")} (${isoLabel})`);
     }
     else {
         lines.push(`  # Group ${group.group_index}: ${group.step_ids[0]} (sequential)`);
@@ -213,8 +221,62 @@ function generateGroupExecution(group, stepMap, options, plan) {
         const varId = sanitizeForBash(id);
         lines.push(`  STEP_${varId}_STATUS=0`);
     }
-    if (isParallel) {
-        // Background jobs
+    if (isParallel && group.isolation === "worktree") {
+        // Worktree-isolated parallel execution
+        lines.push("");
+        lines.push('  MAIN_BRANCH=$(git rev-parse --abbrev-ref HEAD)');
+        // Create worktrees
+        for (const id of group.step_ids) {
+            const safeId = sanitizeForShell(id);
+            lines.push(`  git worktree add ".dna/worktrees/${safeId}" -b "dna-wt-${safeId}" HEAD 2>/dev/null`);
+        }
+        // Background jobs in worktree dirs
+        for (const id of group.step_ids) {
+            const step = stepMap.get(id);
+            const varId = sanitizeForBash(id);
+            const safeId = sanitizeForShell(id);
+            const agent = agentName(step.role, options.agentPrefix);
+            const prompt = escapeShellSingleQuote(step.prompt ?? step.description);
+            lines.push("");
+            lines.push(`  (cd ".dna/worktrees/${safeId}" && run_agent "${agent}" '${prompt}' "${safeId}") &`);
+            lines.push(`  PID_${varId}=$!`);
+        }
+        lines.push("");
+        // Wait for all
+        for (const id of group.step_ids) {
+            const step = stepMap.get(id);
+            const varId = sanitizeForBash(id);
+            if (step.optional) {
+                lines.push(`  wait $PID_${varId} || {`);
+                lines.push(`    STEP_${varId}_STATUS=1`);
+                lines.push(`    echo "[$(date '+%H:%M:%S')] Optional step '${step.id}' failed, continuing..."`);
+                lines.push("  }");
+            }
+            else {
+                lines.push(`  wait $PID_${varId} || STEP_${varId}_STATUS=1`);
+            }
+        }
+        // Merge worktrees back (escalate on conflict)
+        lines.push("");
+        lines.push("  # Merge worktrees back to main branch");
+        for (const id of group.step_ids) {
+            const varId = sanitizeForBash(id);
+            const safeId = sanitizeForShell(id);
+            lines.push(`  if [ "$STEP_${varId}_STATUS" -eq 0 ]; then`);
+            lines.push(`    merge_worktree "dna-wt-${safeId}" "${safeId}"`);
+            lines.push("  fi");
+        }
+        // Cleanup worktrees
+        lines.push("");
+        lines.push("  # Cleanup worktrees");
+        for (const id of group.step_ids) {
+            const safeId = sanitizeForShell(id);
+            lines.push(`  git worktree remove ".dna/worktrees/${safeId}" 2>/dev/null || true`);
+            lines.push(`  git branch -D "dna-wt-${safeId}" 2>/dev/null || true`);
+        }
+    }
+    else if (isParallel) {
+        // Standard parallel execution (no isolation)
         for (const id of group.step_ids) {
             const step = stepMap.get(id);
             const varId = sanitizeForBash(id);
@@ -248,6 +310,32 @@ function generateGroupExecution(group, stepMap, options, plan) {
     }
     return lines;
 }
+/**
+ * Check if any parallel group in the plan uses worktree isolation.
+ */
+function needsWorktreeSupport(plan) {
+    return plan.parallel_groups.some(g => g.isolation === "worktree" && g.step_ids.length > 1);
+}
+/**
+ * Generate the merge_worktree bash helper function.
+ * Only included in scripts that have worktree-isolated parallel groups.
+ */
+function generateMergeWorktreeFn() {
+    return [
+        "# Merge a worktree branch back to main (escalate on conflict)",
+        "merge_worktree() {",
+        '  local branch="$1" name="$2"',
+        '  if ! git merge --no-commit --no-ff "$branch" 2>/dev/null; then',
+        "    git merge --abort",
+        '    echo "[Intent DNA] CONFLICT: $name conflicts with current branch. Manual resolution required."',
+        '    echo "[Intent DNA] Branch preserved: $branch"',
+        "    return 1",
+        "  fi",
+        '  git commit -m "merge: $name" --no-edit 2>/dev/null || true',
+        "}",
+        "",
+    ];
+}
 /**
  * Generate transition check code after all groups execute.
  */
@@ -316,6 +404,10 @@ export function compileWorkflowToShell(plan, options) {
     // run_agent function
     lines.push(...generateRunAgentFn(opts));
     lines.push("");
+    // merge_worktree function (only if needed)
+    if (needsWorktreeSupport(plan)) {
+        lines.push(...generateMergeWorktreeFn());
+    }
     // Main execution
     if (plan.retry.max_retries > 0) {
         // With retry loop

package/dist/schema/types.d.ts

@@ -154,6 +154,16 @@ export interface WorkflowDef {
     default_isolation?: "none" | "worktree" | "auto";
     merge_strategy?: "escalate";
 }
+/** Parallel block syntax sugar — expanded by compiler into steps with depends_on */
+export interface ParallelBlockDef {
+    parallel: {
+        isolation?: "none" | "worktree" | "auto";
+        merge_strategy?: "escalate";
+        steps: WorkflowStepDef[];
+    };
+}
+/** Raw workflow step entry: either a regular step or a parallel block (syntax sugar) */
+export type RawWorkflowStepEntry = WorkflowStepDef | ParallelBlockDef;
 export interface EpigeneticEffect {
     gene?: string;
     action?: ModifierAction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "description": "Intent DNA — Declarative policy layer for AI agent behavior",
   "type": "module",
   "main": "dist/index.js",